/*
* Copyright 2010-2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
/*
* Do not modify this file. This file is generated from the dynamodb-2012-08-10.normal.json service model.
*/
using System;
using System.Collections.Generic;
using System.Net;
using Amazon.DynamoDBv2.Model;
using Amazon.DynamoDBv2.Model.Internal.MarshallTransformations;
using Amazon.DynamoDBv2.Internal;
using Amazon.Runtime;
using Amazon.Runtime.Internal;
using Amazon.Runtime.Internal.Auth;
using Amazon.Runtime.Internal.Transform;
namespace Amazon.DynamoDBv2
{
///
/// Implementation for accessing DynamoDB
///
/// Amazon DynamoDB
///
/// Amazon DynamoDB is a fully managed NoSQL database service that provides fast and predictable
/// performance with seamless scalability. DynamoDB lets you offload the administrative
/// burdens of operating and scaling a distributed database, so that you don't have to
/// worry about hardware provisioning, setup and configuration, replication, software
/// patching, or cluster scaling.
///
///
///
/// With DynamoDB, you can create database tables that can store and retrieve any amount
/// of data, and serve any level of request traffic. You can scale up or scale down your
/// tables' throughput capacity without downtime or performance degradation, and use the
/// AWS Management Console to monitor resource utilization and performance metrics.
///
///
///
/// DynamoDB automatically spreads the data and traffic for your tables over a sufficient
/// number of servers to handle your throughput and storage requirements, while maintaining
/// consistent and fast performance. All of your data is stored on solid state disks (SSDs)
/// and automatically replicated across multiple Availability Zones in an AWS region,
/// providing built-in high availability and data durability.
///
///
public partial class AmazonDynamoDBClient : AmazonServiceClient, IAmazonDynamoDB
{
private static IServiceMetadata serviceMetadata = new AmazonDynamoDBMetadata();
#region Constructors
///
/// Constructs AmazonDynamoDBClient with AWS Credentials
///
/// AWS Credentials
public AmazonDynamoDBClient(AWSCredentials credentials)
: this(credentials, new AmazonDynamoDBConfig())
{
}
///
/// Constructs AmazonDynamoDBClient with AWS Credentials
///
/// AWS Credentials
/// The region to connect.
public AmazonDynamoDBClient(AWSCredentials credentials, RegionEndpoint region)
: this(credentials, new AmazonDynamoDBConfig{RegionEndpoint = region})
{
}
///
/// Constructs AmazonDynamoDBClient with AWS Credentials and an
/// AmazonDynamoDBClient Configuration object.
///
/// AWS Credentials
/// The AmazonDynamoDBClient Configuration Object
public AmazonDynamoDBClient(AWSCredentials credentials, AmazonDynamoDBConfig clientConfig)
: base(credentials, clientConfig)
{
}
///
/// Constructs AmazonDynamoDBClient with AWS Access Key ID and AWS Secret Key
///
/// AWS Access Key ID
/// AWS Secret Access Key
public AmazonDynamoDBClient(string awsAccessKeyId, string awsSecretAccessKey)
: this(awsAccessKeyId, awsSecretAccessKey, new AmazonDynamoDBConfig())
{
}
///
/// Constructs AmazonDynamoDBClient with AWS Access Key ID and AWS Secret Key
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// The region to connect.
public AmazonDynamoDBClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region)
: this(awsAccessKeyId, awsSecretAccessKey, new AmazonDynamoDBConfig() {RegionEndpoint=region})
{
}
///
/// Constructs AmazonDynamoDBClient with AWS Access Key ID, AWS Secret Key and an
/// AmazonDynamoDBClient Configuration object.
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// The AmazonDynamoDBClient Configuration Object
public AmazonDynamoDBClient(string awsAccessKeyId, string awsSecretAccessKey, AmazonDynamoDBConfig clientConfig)
: base(awsAccessKeyId, awsSecretAccessKey, clientConfig)
{
}
///
/// Constructs AmazonDynamoDBClient with AWS Access Key ID and AWS Secret Key
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// AWS Session Token
public AmazonDynamoDBClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken)
: this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonDynamoDBConfig())
{
}
///
/// Constructs AmazonDynamoDBClient with AWS Access Key ID and AWS Secret Key
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// AWS Session Token
/// The region to connect.
public AmazonDynamoDBClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region)
: this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonDynamoDBConfig{RegionEndpoint = region})
{
}
///
/// Constructs AmazonDynamoDBClient with AWS Access Key ID, AWS Secret Key and an
/// AmazonDynamoDBClient Configuration object.
///
/// AWS Access Key ID
/// AWS Secret Access Key
/// AWS Session Token
/// The AmazonDynamoDBClient Configuration Object
public AmazonDynamoDBClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonDynamoDBConfig clientConfig)
: base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig)
{
}
#endregion
#region Overrides
///
/// Creates the signer for the service.
///
protected override AbstractAWSSigner CreateSigner()
{
return new AWS4Signer();
}
///
/// Customizes the runtime pipeline.
///
/// Runtime pipeline for the current client.
protected override void CustomizeRuntimePipeline(RuntimePipeline pipeline)
{
pipeline.ReplaceHandler(new Amazon.Runtime.Internal.RetryHandler(new Amazon.DynamoDBv2.Internal.DynamoDBRetryPolicy(this.Config)));
}
///
/// Capture metadata for the service.
///
protected override IServiceMetadata ServiceMetadata
{
get
{
return serviceMetadata;
}
}
#endregion
#region Dispose
///
/// Disposes the service client.
///
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
}
#endregion
#region EndpointOperation Override
protected override IEnumerable EndpointOperation(EndpointOperationContextBase context)
{
return EndpointDiscoveryResolver.ResolveEndpoints(context, () =>
{
var request = new DescribeEndpointsRequest
{
};
var response = DescribeEndpoints(request);
if(response.HttpStatusCode != HttpStatusCode.OK || response.Endpoints == null)
{
return null;
}
var endpoints = new List();
foreach(var endpoint in response.Endpoints)
{
endpoints.Add(new DiscoveryEndpoint(endpoint.Address, endpoint.CachePeriodInMinutes));
}
return endpoints;
});
}
#endregion
#region BatchGetItem
internal virtual BatchGetItemResponse BatchGetItem(BatchGetItemRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = BatchGetItemRequestMarshaller.Instance;
options.ResponseUnmarshaller = BatchGetItemResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = BatchGetItemEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// The BatchGetItem operation returns the attributes of one or more items
/// from one or more tables. You identify requested items by primary key.
///
///
///
/// A single operation can retrieve up to 16 MB of data, which can contain as many as
/// 100 items. BatchGetItem returns a partial result if the response size
/// limit is exceeded, the table's provisioned throughput is exceeded, or an internal
/// processing failure occurs. If a partial result is returned, the operation returns
/// a value for UnprocessedKeys. You can use this value to retry the operation
/// starting with the next item to get.
///
///
///
/// If you request more than 100 items, BatchGetItem returns a ValidationException
/// with the message "Too many items requested for the BatchGetItem call."
///
///
///
/// For example, if you ask to retrieve 100 items, but each individual item is 300 KB
/// in size, the system returns 52 items (so as not to exceed the 16 MB limit). It also
/// returns an appropriate UnprocessedKeys value so you can get the next
/// page of results. If desired, your application can include its own logic to assemble
/// the pages of results into one dataset.
///
///
///
/// If none of the items can be processed due to insufficient provisioned throughput
/// on all of the tables in the request, then BatchGetItem returns a ProvisionedThroughputExceededException.
/// If at least one of the items is successfully processed, then BatchGetItem
/// completes successfully, while returning the keys of the unread items in UnprocessedKeys.
///
///
///
/// If DynamoDB returns any unprocessed items, you should retry the batch operation on
/// those items. However, we strongly recommend that you use an exponential backoff
/// algorithm. If you retry the batch operation immediately, the underlying read or
/// write requests can still fail due to throttling on the individual tables. If you delay
/// the batch operation using exponential backoff, the individual requests in the batch
/// are much more likely to succeed.
///
///
///
/// For more information, see Batch
/// Operations and Error Handling in the Amazon DynamoDB Developer Guide.
///
///
///
/// By default, BatchGetItem performs eventually consistent reads on every
/// table in the request. If you want strongly consistent reads instead, you can set ConsistentRead
/// to true for any or all tables.
///
///
///
/// In order to minimize response latency, BatchGetItem retrieves items in
/// parallel.
///
///
///
/// When designing your application, keep in mind that DynamoDB does not return items
/// in any particular order. To help parse the response by item, include the primary key
/// values for the items in your request in the ProjectionExpression parameter.
///
///
///
/// If a requested item does not exist, it is not returned in the result. Requests for
/// nonexistent items consume the minimum read capacity units according to the type of
/// read. For more information, see Working
/// with Tables in the Amazon DynamoDB Developer Guide.
///
///
/// A map of one or more table names and, for each table, a map that describes one or more items to retrieve from that table. Each table name can be used only once per BatchGetItem request. Each element in the map of items to retrieve consists of the following: -
ConsistentRead - If true, a strongly consistent read is used; if false (the default), an eventually consistent read is used. -
ExpressionAttributeNames - One or more substitution tokens for attribute names in the ProjectionExpression parameter. The following are some use cases for using ExpressionAttributeNames: - To access an attribute whose name conflicts with a DynamoDB reserved word.
- To create a placeholder for repeating occurrences of an attribute name in an expression.
- To prevent special characters in an attribute name from being misinterpreted in an expression.
Use the # character in an expression to dereference an attribute name. For example, consider the following attribute name: The name of this attribute conflicts with a reserved word, so it cannot be used directly in an expression. (For the complete list of reserved words, see Reserved Words in the Amazon DynamoDB Developer Guide). To work around this, you could specify the following for ExpressionAttributeNames: You could then use this substitution in an expression, as in this example: Tokens that begin with the : character are expression attribute values, which are placeholders for the actual value at runtime. For more information about expression attribute names, see Accessing Item Attributes in the Amazon DynamoDB Developer Guide. -
Keys - An array of primary key attribute values that define specific items in the table. For each primary key, you must provide all of the key attributes. For example, with a simple primary key, you only need to provide the partition key value. For a composite key, you must provide both the partition key value and the sort key value. -
ProjectionExpression - A string that identifies one or more attributes to retrieve from the table. These attributes can include scalars, sets, or elements of a JSON document. The attributes in the expression must be separated by commas. If no attribute names are specified, then all attributes are returned. If any of the requested attributes are not found, they do not appear in the result. For more information, see Accessing Item Attributes in the Amazon DynamoDB Developer Guide. -
AttributesToGet - This is a legacy parameter. Use ProjectionExpression instead. For more information, see AttributesToGet in the Amazon DynamoDB Developer Guide.
/// A property of BatchGetItemRequest used to execute the BatchGetItem service method.
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the BatchGetItem service method, as returned by DynamoDB.
///
/// An error occurred on the server side.
///
///
/// Your request rate is too high. The AWS SDKs for DynamoDB automatically retry requests
/// that receive this exception. Your request is eventually successful, unless your retry
/// queue is too large to finish. Reduce the frequency of requests and use exponential
/// backoff. For more information, go to Error
/// Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
///
///
/// Throughput exceeds the current throughput limit for your account. Please contact AWS
/// Support at AWS Support to request a limit
/// increase.
///
///
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be ACTIVE.
///
/// REST API Reference for BatchGetItem Operation
public virtual void BatchGetItemAsync(Dictionary requestItems, ReturnConsumedCapacity returnConsumedCapacity, AmazonServiceCallback callback, AsyncOptions options = null)
{
var request = new BatchGetItemRequest();
request.RequestItems = requestItems;
request.ReturnConsumedCapacity = returnConsumedCapacity;
BatchGetItemAsync(request, callback, options);
}
///
/// The BatchGetItem operation returns the attributes of one or more items
/// from one or more tables. You identify requested items by primary key.
///
///
///
/// A single operation can retrieve up to 16 MB of data, which can contain as many as
/// 100 items. BatchGetItem returns a partial result if the response size
/// limit is exceeded, the table's provisioned throughput is exceeded, or an internal
/// processing failure occurs. If a partial result is returned, the operation returns
/// a value for UnprocessedKeys. You can use this value to retry the operation
/// starting with the next item to get.
///
///
///
/// If you request more than 100 items, BatchGetItem returns a ValidationException
/// with the message "Too many items requested for the BatchGetItem call."
///
///
///
/// For example, if you ask to retrieve 100 items, but each individual item is 300 KB
/// in size, the system returns 52 items (so as not to exceed the 16 MB limit). It also
/// returns an appropriate UnprocessedKeys value so you can get the next
/// page of results. If desired, your application can include its own logic to assemble
/// the pages of results into one dataset.
///
///
///
/// If none of the items can be processed due to insufficient provisioned throughput
/// on all of the tables in the request, then BatchGetItem returns a ProvisionedThroughputExceededException.
/// If at least one of the items is successfully processed, then BatchGetItem
/// completes successfully, while returning the keys of the unread items in UnprocessedKeys.
///
///
///
/// If DynamoDB returns any unprocessed items, you should retry the batch operation on
/// those items. However, we strongly recommend that you use an exponential backoff
/// algorithm. If you retry the batch operation immediately, the underlying read or
/// write requests can still fail due to throttling on the individual tables. If you delay
/// the batch operation using exponential backoff, the individual requests in the batch
/// are much more likely to succeed.
///
///
///
/// For more information, see Batch
/// Operations and Error Handling in the Amazon DynamoDB Developer Guide.
///
///
///
/// By default, BatchGetItem performs eventually consistent reads on every
/// table in the request. If you want strongly consistent reads instead, you can set ConsistentRead
/// to true for any or all tables.
///
///
///
/// In order to minimize response latency, BatchGetItem retrieves items in
/// parallel.
///
///
///
/// When designing your application, keep in mind that DynamoDB does not return items
/// in any particular order. To help parse the response by item, include the primary key
/// values for the items in your request in the ProjectionExpression parameter.
///
///
///
/// If a requested item does not exist, it is not returned in the result. Requests for
/// nonexistent items consume the minimum read capacity units according to the type of
/// read. For more information, see Working
/// with Tables in the Amazon DynamoDB Developer Guide.
///
///
/// A map of one or more table names and, for each table, a map that describes one or more items to retrieve from that table. Each table name can be used only once per BatchGetItem request. Each element in the map of items to retrieve consists of the following: -
ConsistentRead - If true, a strongly consistent read is used; if false (the default), an eventually consistent read is used. -
ExpressionAttributeNames - One or more substitution tokens for attribute names in the ProjectionExpression parameter. The following are some use cases for using ExpressionAttributeNames: - To access an attribute whose name conflicts with a DynamoDB reserved word.
- To create a placeholder for repeating occurrences of an attribute name in an expression.
- To prevent special characters in an attribute name from being misinterpreted in an expression.
Use the # character in an expression to dereference an attribute name. For example, consider the following attribute name: The name of this attribute conflicts with a reserved word, so it cannot be used directly in an expression. (For the complete list of reserved words, see Reserved Words in the Amazon DynamoDB Developer Guide). To work around this, you could specify the following for ExpressionAttributeNames: You could then use this substitution in an expression, as in this example: Tokens that begin with the : character are expression attribute values, which are placeholders for the actual value at runtime. For more information about expression attribute names, see Accessing Item Attributes in the Amazon DynamoDB Developer Guide. -
Keys - An array of primary key attribute values that define specific items in the table. For each primary key, you must provide all of the key attributes. For example, with a simple primary key, you only need to provide the partition key value. For a composite key, you must provide both the partition key value and the sort key value. -
ProjectionExpression - A string that identifies one or more attributes to retrieve from the table. These attributes can include scalars, sets, or elements of a JSON document. The attributes in the expression must be separated by commas. If no attribute names are specified, then all attributes are returned. If any of the requested attributes are not found, they do not appear in the result. For more information, see Accessing Item Attributes in the Amazon DynamoDB Developer Guide. -
AttributesToGet - This is a legacy parameter. Use ProjectionExpression instead. For more information, see AttributesToGet in the Amazon DynamoDB Developer Guide.
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the BatchGetItem service method, as returned by DynamoDB.
///
/// An error occurred on the server side.
///
///
/// Your request rate is too high. The AWS SDKs for DynamoDB automatically retry requests
/// that receive this exception. Your request is eventually successful, unless your retry
/// queue is too large to finish. Reduce the frequency of requests and use exponential
/// backoff. For more information, go to Error
/// Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
///
///
/// Throughput exceeds the current throughput limit for your account. Please contact AWS
/// Support at AWS Support to request a limit
/// increase.
///
///
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be ACTIVE.
///
/// REST API Reference for BatchGetItem Operation
public virtual void BatchGetItemAsync(Dictionary requestItems, AmazonServiceCallback callback, AsyncOptions options = null)
{
var request = new BatchGetItemRequest();
request.RequestItems = requestItems;
BatchGetItemAsync(request, callback, options);
}
///
/// Initiates the asynchronous execution of the BatchGetItem operation.
///
///
/// Container for the necessary parameters to execute the BatchGetItem operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for BatchGetItem Operation
public virtual void BatchGetItemAsync(BatchGetItemRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = BatchGetItemRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = BatchGetItemResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = BatchGetItemEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((BatchGetItemRequest)req, (BatchGetItemResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region BatchWriteItem
internal virtual BatchWriteItemResponse BatchWriteItem(BatchWriteItemRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = BatchWriteItemRequestMarshaller.Instance;
options.ResponseUnmarshaller = BatchWriteItemResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = BatchWriteItemEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// The BatchWriteItem operation puts or deletes multiple items in one or
/// more tables. A single call to BatchWriteItem can write up to 16 MB of
/// data, which can comprise as many as 25 put or delete requests. Individual items to
/// be written can be as large as 400 KB.
///
///
///
/// BatchWriteItem cannot update items. To update items, use the UpdateItem
/// action.
///
///
///
/// The individual PutItem and DeleteItem operations specified
/// in BatchWriteItem are atomic; however BatchWriteItem as
/// a whole is not. If any requested operations fail because the table's provisioned throughput
/// is exceeded or an internal processing failure occurs, the failed operations are returned
/// in the UnprocessedItems response parameter. You can investigate and optionally
/// resend the requests. Typically, you would call BatchWriteItem in a loop.
/// Each iteration would check for unprocessed items and submit a new BatchWriteItem
/// request with those unprocessed items until all items have been processed.
///
///
///
/// If none of the items can be processed due to insufficient provisioned throughput
/// on all of the tables in the request, then BatchWriteItem returns a ProvisionedThroughputExceededException.
///
///
///
/// If DynamoDB returns any unprocessed items, you should retry the batch operation on
/// those items. However, we strongly recommend that you use an exponential backoff
/// algorithm. If you retry the batch operation immediately, the underlying read or
/// write requests can still fail due to throttling on the individual tables. If you delay
/// the batch operation using exponential backoff, the individual requests in the batch
/// are much more likely to succeed.
///
///
///
/// For more information, see Batch
/// Operations and Error Handling in the Amazon DynamoDB Developer Guide.
///
///
///
/// With BatchWriteItem, you can efficiently write or delete large amounts
/// of data, such as from Amazon EMR, or copy data from another database into DynamoDB.
/// In order to improve performance with these large-scale operations, BatchWriteItem
/// does not behave in the same way as individual PutItem and DeleteItem
/// calls would. For example, you cannot specify conditions on individual put and delete
/// requests, and BatchWriteItem does not return deleted items in the response.
///
///
///
/// If you use a programming language that supports concurrency, you can use threads to
/// write items in parallel. Your application must include the necessary logic to manage
/// the threads. With languages that don't support threading, you must update or delete
/// the specified items one at a time. In both situations, BatchWriteItem
/// performs the specified put and delete operations in parallel, giving you the power
/// of the thread pool approach without having to introduce complexity into your application.
///
///
///
/// Parallel processing reduces latency, but each specified put and delete request consumes
/// the same number of write capacity units whether it is processed in parallel or not.
/// Delete operations on nonexistent items consume one write capacity unit.
///
///
///
/// If one or more of the following is true, DynamoDB rejects the entire batch write operation:
///
/// -
///
/// One or more tables specified in the
BatchWriteItem request does not exist.
///
/// -
///
/// Primary key attributes specified on an item in the request do not match those in the
/// corresponding table's primary key schema.
///
///
-
///
/// You try to perform multiple operations on the same item in the same
BatchWriteItem
/// request. For example, you cannot put and delete the same item in the same BatchWriteItem
/// request.
///
/// -
///
/// Your request contains at least two items with identical hash and range keys (which
/// essentially is two put operations).
///
///
-
///
/// There are more than 25 requests in the batch.
///
///
-
///
/// Any individual item in a batch exceeds 400 KB.
///
///
-
///
/// The total request size exceeds 16 MB.
///
///
///
/// A map of one or more table names and, for each table, a list of operations to be performed (DeleteRequest or PutRequest). Each element in the map consists of the following: -
DeleteRequest - Perform a DeleteItem operation on the specified item. The item to be deleted is identified by a Key subelement: -
Key - A map of primary key attribute values that uniquely identify the item. Each entry in this map consists of an attribute name and an attribute value. For each primary key, you must provide all of the key attributes. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide values for both the partition key and the sort key.
-
PutRequest - Perform a PutItem operation on the specified item. The item to be put is identified by an Item subelement: -
Item - A map of attributes and their values. Each entry in this map consists of an attribute name and an attribute value. Attribute values must not be null; string and binary type attributes must have lengths greater than zero; and set type attributes must not be empty. Requests that contain empty values are rejected with a ValidationException exception. If you specify any attributes that are part of an index key, then the data types for those attributes must match those of the schema in the table's attribute definition.
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the BatchWriteItem service method, as returned by DynamoDB.
///
/// An error occurred on the server side.
///
///
/// An item collection is too large. This exception is only returned for tables that have
/// one or more local secondary indexes.
///
///
/// Your request rate is too high. The AWS SDKs for DynamoDB automatically retry requests
/// that receive this exception. Your request is eventually successful, unless your retry
/// queue is too large to finish. Reduce the frequency of requests and use exponential
/// backoff. For more information, go to Error
/// Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
///
///
/// Throughput exceeds the current throughput limit for your account. Please contact AWS
/// Support at AWS Support to request a limit
/// increase.
///
///
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be ACTIVE.
///
/// REST API Reference for BatchWriteItem Operation
public virtual void BatchWriteItemAsync(Dictionary> requestItems, AmazonServiceCallback callback, AsyncOptions options = null)
{
var request = new BatchWriteItemRequest();
request.RequestItems = requestItems;
BatchWriteItemAsync(request, callback, options);
}
///
/// Initiates the asynchronous execution of the BatchWriteItem operation.
///
///
/// Container for the necessary parameters to execute the BatchWriteItem operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for BatchWriteItem Operation
public virtual void BatchWriteItemAsync(BatchWriteItemRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = BatchWriteItemRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = BatchWriteItemResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = BatchWriteItemEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((BatchWriteItemRequest)req, (BatchWriteItemResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region CreateBackup
internal virtual CreateBackupResponse CreateBackup(CreateBackupRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateBackupRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateBackupResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = CreateBackupEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the CreateBackup operation.
///
///
/// Container for the necessary parameters to execute the CreateBackup operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for CreateBackup Operation
public virtual void CreateBackupAsync(CreateBackupRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = CreateBackupRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = CreateBackupResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = CreateBackupEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((CreateBackupRequest)req, (CreateBackupResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region CreateGlobalTable
internal virtual CreateGlobalTableResponse CreateGlobalTable(CreateGlobalTableRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateGlobalTableRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateGlobalTableResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = CreateGlobalTableEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the CreateGlobalTable operation.
///
///
/// Container for the necessary parameters to execute the CreateGlobalTable operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for CreateGlobalTable Operation
public virtual void CreateGlobalTableAsync(CreateGlobalTableRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = CreateGlobalTableRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = CreateGlobalTableResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = CreateGlobalTableEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((CreateGlobalTableRequest)req, (CreateGlobalTableResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region CreateTable
internal virtual CreateTableResponse CreateTable(CreateTableRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateTableRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateTableResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = CreateTableEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// The CreateTable operation adds a new table to your account. In an AWS
/// account, table names must be unique within each Region. That is, you can have two
/// tables with same name if you create the tables in different Regions.
///
///
///
/// CreateTable is an asynchronous operation. Upon receiving a CreateTable
/// request, DynamoDB immediately returns a response with a TableStatus of
/// CREATING. After the table is created, DynamoDB sets the TableStatus
/// to ACTIVE. You can perform read and write operations only on an ACTIVE
/// table.
///
///
///
/// You can optionally define secondary indexes on the new table, as part of the CreateTable
/// operation. If you want to create multiple tables with secondary indexes on them, you
/// must create the tables sequentially. Only one table with secondary indexes can be
/// in the CREATING state at any given time.
///
///
///
/// You can use the DescribeTable action to check the table status.
///
///
/// The name of the table to create.
/// Specifies the attributes that make up the primary key for a table or an index. The attributes in KeySchema must also be defined in the AttributeDefinitions array. For more information, see Data Model in the Amazon DynamoDB Developer Guide. Each KeySchemaElement in the array is composed of: -
AttributeName - The name of this key attribute. -
KeyType - The role that the key attribute will assume: -
HASH - partition key -
RANGE - sort key
The partition key of an item is also known as its hash attribute. The term "hash attribute" derives from the DynamoDB usage of an internal hash function to evenly distribute data items across partitions, based on their partition key values. The sort key of an item is also known as its range attribute. The term "range attribute" derives from the way DynamoDB stores items with the same partition key physically close together, in sorted order by the sort key value. For a simple primary key (partition key), you must provide exactly one element with a KeyType of HASH. For a composite primary key (partition key and sort key), you must provide exactly two elements, in this order: The first element must have a KeyType of HASH, and the second element must have a KeyType of RANGE. For more information, see Working with Tables in the Amazon DynamoDB Developer Guide.
/// An array of attributes that describe the key schema for the table and indexes.
/// Represents the provisioned throughput settings for a specified table or index. The settings can be modified using the UpdateTable operation. If you set BillingMode as PROVISIONED, you must specify this property. If you set BillingMode as PAY_PER_REQUEST, you cannot specify this property. For current minimum and maximum provisioned throughput values, see Limits in the Amazon DynamoDB Developer Guide.
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the CreateTable service method, as returned by DynamoDB.
///
/// An error occurred on the server side.
///
///
/// There is no limit to the number of daily on-demand backups that can be taken.
///
///
///
/// Up to 50 simultaneous table operations are allowed per account. These operations include
/// CreateTable, UpdateTable, DeleteTable,UpdateTimeToLive,
/// RestoreTableFromBackup, and RestoreTableToPointInTime.
///
///
///
/// The only exception is when you are creating a table with one or more secondary indexes.
/// You can have up to 25 such requests running at a time; however, if the table or index
/// specifications are complex, DynamoDB might temporarily reduce the number of concurrent
/// operations.
///
///
///
/// There is a soft account limit of 256 tables.
///
///
///
/// The operation conflicts with the resource's availability. For example, you attempted
/// to recreate an existing table, or tried to delete a table currently in the CREATING
/// state.
///
/// REST API Reference for CreateTable Operation
public virtual void CreateTableAsync(string tableName, List keySchema, List attributeDefinitions, ProvisionedThroughput provisionedThroughput, AmazonServiceCallback callback, AsyncOptions options = null)
{
var request = new CreateTableRequest();
request.TableName = tableName;
request.KeySchema = keySchema;
request.AttributeDefinitions = attributeDefinitions;
request.ProvisionedThroughput = provisionedThroughput;
CreateTableAsync(request, callback, options);
}
///
/// Initiates the asynchronous execution of the CreateTable operation.
///
///
/// Container for the necessary parameters to execute the CreateTable operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for CreateTable Operation
public virtual void CreateTableAsync(CreateTableRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = CreateTableRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = CreateTableResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = CreateTableEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((CreateTableRequest)req, (CreateTableResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region DeleteBackup
internal virtual DeleteBackupResponse DeleteBackup(DeleteBackupRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteBackupRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteBackupResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = DeleteBackupEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the DeleteBackup operation.
///
///
/// Container for the necessary parameters to execute the DeleteBackup operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for DeleteBackup Operation
public virtual void DeleteBackupAsync(DeleteBackupRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = DeleteBackupRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = DeleteBackupResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = DeleteBackupEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((DeleteBackupRequest)req, (DeleteBackupResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region DeleteItem
internal virtual DeleteItemResponse DeleteItem(DeleteItemRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteItemRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteItemResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = DeleteItemEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Deletes a single item in a table by primary key. You can perform a conditional delete
/// operation that deletes the item if it exists, or if it has an expected attribute value.
///
///
///
/// In addition to deleting an item, you can also return the item's attribute values in
/// the same operation, using the ReturnValues parameter.
///
///
///
/// Unless you specify conditions, the DeleteItem is an idempotent operation;
/// running it multiple times on the same item or attribute does not result in
/// an error response.
///
///
///
/// Conditional deletes are useful for deleting items only if specific conditions are
/// met. If those conditions are met, DynamoDB performs the delete. Otherwise, the item
/// is not deleted.
///
///
/// The name of the table from which to delete the item.
/// A map of attribute names to AttributeValue objects, representing the primary key of the item to delete. For the primary key, you must provide all of the attributes. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide values for both the partition key and the sort key.
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the DeleteItem service method, as returned by DynamoDB.
///
/// A condition specified in the operation could not be evaluated.
///
///
/// An error occurred on the server side.
///
///
/// An item collection is too large. This exception is only returned for tables that have
/// one or more local secondary indexes.
///
///
/// Your request rate is too high. The AWS SDKs for DynamoDB automatically retry requests
/// that receive this exception. Your request is eventually successful, unless your retry
/// queue is too large to finish. Reduce the frequency of requests and use exponential
/// backoff. For more information, go to Error
/// Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
///
///
/// Throughput exceeds the current throughput limit for your account. Please contact AWS
/// Support at AWS Support to request a limit
/// increase.
///
///
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be ACTIVE.
///
///
/// Operation was rejected because there is an ongoing transaction for the item.
///
/// REST API Reference for DeleteItem Operation
public virtual void DeleteItemAsync(string tableName, Dictionary key, AmazonServiceCallback callback, AsyncOptions options = null)
{
var request = new DeleteItemRequest();
request.TableName = tableName;
request.Key = key;
DeleteItemAsync(request, callback, options);
}
///
/// Deletes a single item in a table by primary key. You can perform a conditional delete
/// operation that deletes the item if it exists, or if it has an expected attribute value.
///
///
///
/// In addition to deleting an item, you can also return the item's attribute values in
/// the same operation, using the ReturnValues parameter.
///
///
///
/// Unless you specify conditions, the DeleteItem is an idempotent operation;
/// running it multiple times on the same item or attribute does not result in
/// an error response.
///
///
///
/// Conditional deletes are useful for deleting items only if specific conditions are
/// met. If those conditions are met, DynamoDB performs the delete. Otherwise, the item
/// is not deleted.
///
///
/// The name of the table from which to delete the item.
/// A map of attribute names to AttributeValue objects, representing the primary key of the item to delete. For the primary key, you must provide all of the attributes. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide values for both the partition key and the sort key.
/// Use ReturnValues if you want to get the item attributes as they appeared before they were deleted. For DeleteItem, the valid values are: -
NONE - If ReturnValues is not specified, or if its value is NONE, then nothing is returned. (This setting is the default for ReturnValues.) -
ALL_OLD - The content of the old item is returned.
The ReturnValues parameter is used by several DynamoDB operations; however, DeleteItem does not recognize any values other than NONE or ALL_OLD.
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the DeleteItem service method, as returned by DynamoDB.
///
/// A condition specified in the operation could not be evaluated.
///
///
/// An error occurred on the server side.
///
///
/// An item collection is too large. This exception is only returned for tables that have
/// one or more local secondary indexes.
///
///
/// Your request rate is too high. The AWS SDKs for DynamoDB automatically retry requests
/// that receive this exception. Your request is eventually successful, unless your retry
/// queue is too large to finish. Reduce the frequency of requests and use exponential
/// backoff. For more information, go to Error
/// Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
///
///
/// Throughput exceeds the current throughput limit for your account. Please contact AWS
/// Support at AWS Support to request a limit
/// increase.
///
///
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be ACTIVE.
///
///
/// Operation was rejected because there is an ongoing transaction for the item.
///
/// REST API Reference for DeleteItem Operation
public virtual void DeleteItemAsync(string tableName, Dictionary key, ReturnValue returnValues, AmazonServiceCallback callback, AsyncOptions options = null)
{
var request = new DeleteItemRequest();
request.TableName = tableName;
request.Key = key;
request.ReturnValues = returnValues;
DeleteItemAsync(request, callback, options);
}
///
/// Initiates the asynchronous execution of the DeleteItem operation.
///
///
/// Container for the necessary parameters to execute the DeleteItem operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for DeleteItem Operation
public virtual void DeleteItemAsync(DeleteItemRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = DeleteItemRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = DeleteItemResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = DeleteItemEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((DeleteItemRequest)req, (DeleteItemResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region DeleteTable
internal virtual DeleteTableResponse DeleteTable(DeleteTableRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteTableRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteTableResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = DeleteTableEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// The DeleteTable operation deletes a table and all of its items. After
/// a DeleteTable request, the specified table is in the DELETING
/// state until DynamoDB completes the deletion. If the table is in the ACTIVE
/// state, you can delete it. If a table is in CREATING or UPDATING
/// states, then DynamoDB returns a ResourceInUseException. If the specified
/// table does not exist, DynamoDB returns a ResourceNotFoundException. If
/// table is already in the DELETING state, no error is returned.
///
///
///
/// DynamoDB might continue to accept data read and write operations, such as GetItem
/// and PutItem, on a table in the DELETING state until the
/// table deletion is complete.
///
///
///
/// When you delete a table, any indexes on that table are also deleted.
///
///
///
/// If you have DynamoDB Streams enabled on the table, then the corresponding stream on
/// that table goes into the DISABLED state, and the stream is automatically
/// deleted after 24 hours.
///
///
///
/// Use the DescribeTable action to check the status of the table.
///
///
/// The name of the table to delete.
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the DeleteTable service method, as returned by DynamoDB.
///
/// An error occurred on the server side.
///
///
/// There is no limit to the number of daily on-demand backups that can be taken.
///
///
///
/// Up to 50 simultaneous table operations are allowed per account. These operations include
/// CreateTable, UpdateTable, DeleteTable,UpdateTimeToLive,
/// RestoreTableFromBackup, and RestoreTableToPointInTime.
///
///
///
/// The only exception is when you are creating a table with one or more secondary indexes.
/// You can have up to 25 such requests running at a time; however, if the table or index
/// specifications are complex, DynamoDB might temporarily reduce the number of concurrent
/// operations.
///
///
///
/// There is a soft account limit of 256 tables.
///
///
///
/// The operation conflicts with the resource's availability. For example, you attempted
/// to recreate an existing table, or tried to delete a table currently in the CREATING
/// state.
///
///
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be ACTIVE.
///
/// REST API Reference for DeleteTable Operation
public virtual void DeleteTableAsync(string tableName, AmazonServiceCallback callback, AsyncOptions options = null)
{
var request = new DeleteTableRequest();
request.TableName = tableName;
DeleteTableAsync(request, callback, options);
}
///
/// Initiates the asynchronous execution of the DeleteTable operation.
///
///
/// Container for the necessary parameters to execute the DeleteTable operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for DeleteTable Operation
public virtual void DeleteTableAsync(DeleteTableRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = DeleteTableRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = DeleteTableResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = DeleteTableEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((DeleteTableRequest)req, (DeleteTableResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region DescribeBackup
internal virtual DescribeBackupResponse DescribeBackup(DescribeBackupRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeBackupRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeBackupResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = DescribeBackupEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the DescribeBackup operation.
///
///
/// Container for the necessary parameters to execute the DescribeBackup operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for DescribeBackup Operation
public virtual void DescribeBackupAsync(DescribeBackupRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = DescribeBackupRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = DescribeBackupResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = DescribeBackupEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((DescribeBackupRequest)req, (DescribeBackupResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region DescribeContinuousBackups
internal virtual DescribeContinuousBackupsResponse DescribeContinuousBackups(DescribeContinuousBackupsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeContinuousBackupsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeContinuousBackupsResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = DescribeContinuousBackupsEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the DescribeContinuousBackups operation.
///
///
/// Container for the necessary parameters to execute the DescribeContinuousBackups operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for DescribeContinuousBackups Operation
public virtual void DescribeContinuousBackupsAsync(DescribeContinuousBackupsRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = DescribeContinuousBackupsRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = DescribeContinuousBackupsResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = DescribeContinuousBackupsEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((DescribeContinuousBackupsRequest)req, (DescribeContinuousBackupsResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region DescribeContributorInsights
internal virtual DescribeContributorInsightsResponse DescribeContributorInsights(DescribeContributorInsightsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeContributorInsightsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeContributorInsightsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the DescribeContributorInsights operation.
///
///
/// Container for the necessary parameters to execute the DescribeContributorInsights operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for DescribeContributorInsights Operation
public virtual void DescribeContributorInsightsAsync(DescribeContributorInsightsRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = DescribeContributorInsightsRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = DescribeContributorInsightsResponseUnmarshaller.Instance;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((DescribeContributorInsightsRequest)req, (DescribeContributorInsightsResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region DescribeEndpoints
internal virtual DescribeEndpointsResponse DescribeEndpoints(DescribeEndpointsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeEndpointsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeEndpointsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the DescribeEndpoints operation.
///
///
/// Container for the necessary parameters to execute the DescribeEndpoints operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for DescribeEndpoints Operation
public virtual void DescribeEndpointsAsync(DescribeEndpointsRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = DescribeEndpointsRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = DescribeEndpointsResponseUnmarshaller.Instance;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((DescribeEndpointsRequest)req, (DescribeEndpointsResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region DescribeGlobalTable
internal virtual DescribeGlobalTableResponse DescribeGlobalTable(DescribeGlobalTableRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeGlobalTableRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeGlobalTableResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = DescribeGlobalTableEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the DescribeGlobalTable operation.
///
///
/// Container for the necessary parameters to execute the DescribeGlobalTable operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for DescribeGlobalTable Operation
public virtual void DescribeGlobalTableAsync(DescribeGlobalTableRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = DescribeGlobalTableRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = DescribeGlobalTableResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = DescribeGlobalTableEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((DescribeGlobalTableRequest)req, (DescribeGlobalTableResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region DescribeGlobalTableSettings
internal virtual DescribeGlobalTableSettingsResponse DescribeGlobalTableSettings(DescribeGlobalTableSettingsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeGlobalTableSettingsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeGlobalTableSettingsResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = DescribeGlobalTableSettingsEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the DescribeGlobalTableSettings operation.
///
///
/// Container for the necessary parameters to execute the DescribeGlobalTableSettings operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for DescribeGlobalTableSettings Operation
public virtual void DescribeGlobalTableSettingsAsync(DescribeGlobalTableSettingsRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = DescribeGlobalTableSettingsRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = DescribeGlobalTableSettingsResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = DescribeGlobalTableSettingsEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((DescribeGlobalTableSettingsRequest)req, (DescribeGlobalTableSettingsResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region DescribeLimits
internal virtual DescribeLimitsResponse DescribeLimits(DescribeLimitsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeLimitsRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeLimitsResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = DescribeLimitsEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the DescribeLimits operation.
///
///
/// Container for the necessary parameters to execute the DescribeLimits operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for DescribeLimits Operation
public virtual void DescribeLimitsAsync(DescribeLimitsRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = DescribeLimitsRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = DescribeLimitsResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = DescribeLimitsEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((DescribeLimitsRequest)req, (DescribeLimitsResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region DescribeTable
internal virtual DescribeTableResponse DescribeTable(DescribeTableRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeTableRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeTableResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = DescribeTableEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Returns information about the table, including the current status of the table, when
/// it was created, the primary key schema, and any indexes on the table.
///
///
///
/// If you issue a DescribeTable request immediately after a CreateTable
/// request, DynamoDB might return a ResourceNotFoundException. This is because
/// DescribeTable uses an eventually consistent query, and the metadata for
/// your table might not be available at that moment. Wait for a few seconds, and then
/// try the DescribeTable request again.
///
///
///
/// The name of the table to describe.
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the DescribeTable service method, as returned by DynamoDB.
///
/// An error occurred on the server side.
///
///
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be ACTIVE.
///
/// REST API Reference for DescribeTable Operation
public virtual void DescribeTableAsync(string tableName, AmazonServiceCallback callback, AsyncOptions options = null)
{
var request = new DescribeTableRequest();
request.TableName = tableName;
DescribeTableAsync(request, callback, options);
}
///
/// Initiates the asynchronous execution of the DescribeTable operation.
///
///
/// Container for the necessary parameters to execute the DescribeTable operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for DescribeTable Operation
public virtual void DescribeTableAsync(DescribeTableRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = DescribeTableRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = DescribeTableResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = DescribeTableEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((DescribeTableRequest)req, (DescribeTableResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region DescribeTableReplicaAutoScaling
internal virtual DescribeTableReplicaAutoScalingResponse DescribeTableReplicaAutoScaling(DescribeTableReplicaAutoScalingRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeTableReplicaAutoScalingRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeTableReplicaAutoScalingResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the DescribeTableReplicaAutoScaling operation.
///
///
/// Container for the necessary parameters to execute the DescribeTableReplicaAutoScaling operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for DescribeTableReplicaAutoScaling Operation
public virtual void DescribeTableReplicaAutoScalingAsync(DescribeTableReplicaAutoScalingRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = DescribeTableReplicaAutoScalingRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = DescribeTableReplicaAutoScalingResponseUnmarshaller.Instance;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((DescribeTableReplicaAutoScalingRequest)req, (DescribeTableReplicaAutoScalingResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region DescribeTimeToLive
internal virtual DescribeTimeToLiveResponse DescribeTimeToLive(DescribeTimeToLiveRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeTimeToLiveRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeTimeToLiveResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = DescribeTimeToLiveEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Gives a description of the Time to Live (TTL) status on the specified table.
///
/// The name of the table to be described.
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the DescribeTimeToLive service method, as returned by DynamoDB.
///
/// An error occurred on the server side.
///
///
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be ACTIVE.
///
/// REST API Reference for DescribeTimeToLive Operation
public virtual void DescribeTimeToLiveAsync(string tableName, AmazonServiceCallback callback, AsyncOptions options = null)
{
var request = new DescribeTimeToLiveRequest();
request.TableName = tableName;
DescribeTimeToLiveAsync(request, callback, options);
}
///
/// Initiates the asynchronous execution of the DescribeTimeToLive operation.
///
///
/// Container for the necessary parameters to execute the DescribeTimeToLive operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for DescribeTimeToLive Operation
public virtual void DescribeTimeToLiveAsync(DescribeTimeToLiveRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = DescribeTimeToLiveRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = DescribeTimeToLiveResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = DescribeTimeToLiveEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((DescribeTimeToLiveRequest)req, (DescribeTimeToLiveResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region GetItem
internal virtual GetItemResponse GetItem(GetItemRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetItemRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetItemResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = GetItemEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// The GetItem operation returns a set of attributes for the item with the
/// given primary key. If there is no matching item, GetItem does not return
/// any data and there will be no Item element in the response.
///
///
///
/// GetItem provides an eventually consistent read by default. If your application
/// requires a strongly consistent read, set ConsistentRead to true.
/// Although a strongly consistent read might take more time than an eventually consistent
/// read, it always returns the last updated value.
///
///
/// The name of the table containing the requested item.
/// A map of attribute names to AttributeValue objects, representing the primary key of the item to retrieve. For the primary key, you must provide all of the attributes. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide values for both the partition key and the sort key.
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the GetItem service method, as returned by DynamoDB.
///
/// An error occurred on the server side.
///
///
/// Your request rate is too high. The AWS SDKs for DynamoDB automatically retry requests
/// that receive this exception. Your request is eventually successful, unless your retry
/// queue is too large to finish. Reduce the frequency of requests and use exponential
/// backoff. For more information, go to Error
/// Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
///
///
/// Throughput exceeds the current throughput limit for your account. Please contact AWS
/// Support at AWS Support to request a limit
/// increase.
///
///
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be ACTIVE.
///
/// REST API Reference for GetItem Operation
public virtual void GetItemAsync(string tableName, Dictionary key, AmazonServiceCallback callback, AsyncOptions options = null)
{
var request = new GetItemRequest();
request.TableName = tableName;
request.Key = key;
GetItemAsync(request, callback, options);
}
///
/// The GetItem operation returns a set of attributes for the item with the
/// given primary key. If there is no matching item, GetItem does not return
/// any data and there will be no Item element in the response.
///
///
///
/// GetItem provides an eventually consistent read by default. If your application
/// requires a strongly consistent read, set ConsistentRead to true.
/// Although a strongly consistent read might take more time than an eventually consistent
/// read, it always returns the last updated value.
///
///
/// The name of the table containing the requested item.
/// A map of attribute names to AttributeValue objects, representing the primary key of the item to retrieve. For the primary key, you must provide all of the attributes. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide values for both the partition key and the sort key.
/// Determines the read consistency model: If set to true, then the operation uses strongly consistent reads; otherwise, the operation uses eventually consistent reads.
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the GetItem service method, as returned by DynamoDB.
///
/// An error occurred on the server side.
///
///
/// Your request rate is too high. The AWS SDKs for DynamoDB automatically retry requests
/// that receive this exception. Your request is eventually successful, unless your retry
/// queue is too large to finish. Reduce the frequency of requests and use exponential
/// backoff. For more information, go to Error
/// Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
///
///
/// Throughput exceeds the current throughput limit for your account. Please contact AWS
/// Support at AWS Support to request a limit
/// increase.
///
///
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be ACTIVE.
///
/// REST API Reference for GetItem Operation
public virtual void GetItemAsync(string tableName, Dictionary key, bool consistentRead, AmazonServiceCallback callback, AsyncOptions options = null)
{
var request = new GetItemRequest();
request.TableName = tableName;
request.Key = key;
request.ConsistentRead = consistentRead;
GetItemAsync(request, callback, options);
}
///
/// Initiates the asynchronous execution of the GetItem operation.
///
///
/// Container for the necessary parameters to execute the GetItem operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for GetItem Operation
public virtual void GetItemAsync(GetItemRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = GetItemRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = GetItemResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = GetItemEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((GetItemRequest)req, (GetItemResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region ListBackups
internal virtual ListBackupsResponse ListBackups(ListBackupsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListBackupsRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListBackupsResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = ListBackupsEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the ListBackups operation.
///
///
/// Container for the necessary parameters to execute the ListBackups operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for ListBackups Operation
public virtual void ListBackupsAsync(ListBackupsRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = ListBackupsRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = ListBackupsResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = ListBackupsEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((ListBackupsRequest)req, (ListBackupsResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region ListContributorInsights
internal virtual ListContributorInsightsResponse ListContributorInsights(ListContributorInsightsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListContributorInsightsRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListContributorInsightsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the ListContributorInsights operation.
///
///
/// Container for the necessary parameters to execute the ListContributorInsights operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for ListContributorInsights Operation
public virtual void ListContributorInsightsAsync(ListContributorInsightsRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = ListContributorInsightsRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = ListContributorInsightsResponseUnmarshaller.Instance;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((ListContributorInsightsRequest)req, (ListContributorInsightsResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region ListGlobalTables
internal virtual ListGlobalTablesResponse ListGlobalTables(ListGlobalTablesRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListGlobalTablesRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListGlobalTablesResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = ListGlobalTablesEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the ListGlobalTables operation.
///
///
/// Container for the necessary parameters to execute the ListGlobalTables operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for ListGlobalTables Operation
public virtual void ListGlobalTablesAsync(ListGlobalTablesRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = ListGlobalTablesRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = ListGlobalTablesResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = ListGlobalTablesEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((ListGlobalTablesRequest)req, (ListGlobalTablesResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region ListTables
///
/// Returns an array of table names associated with the current account and endpoint.
/// The output from ListTables is paginated, with each page returning a maximum
/// of 100 table names.
///
///
/// The response from the ListTables service method, as returned by DynamoDB.
///
/// An error occurred on the server side.
///
/// REST API Reference for ListTables Operation
internal virtual ListTablesResponse ListTables()
{
return ListTables(new ListTablesRequest());
}
internal virtual ListTablesResponse ListTables(ListTablesRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListTablesRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListTablesResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = ListTablesEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Returns an array of table names associated with the current account and endpoint.
/// The output from ListTables is paginated, with each page returning a maximum
/// of 100 table names.
///
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the ListTables service method, as returned by DynamoDB.
///
/// An error occurred on the server side.
///
/// REST API Reference for ListTables Operation
public virtual void ListTablesAsync(AmazonServiceCallback callback, AsyncOptions options = null)
{
ListTablesAsync(new ListTablesRequest(), callback, options);
}
///
/// Returns an array of table names associated with the current account and endpoint.
/// The output from ListTables is paginated, with each page returning a maximum
/// of 100 table names.
///
/// The first table name that this operation will evaluate. Use the value that was returned for LastEvaluatedTableName in a previous operation, so that you can obtain the next page of results.
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the ListTables service method, as returned by DynamoDB.
///
/// An error occurred on the server side.
///
/// REST API Reference for ListTables Operation
public virtual void ListTablesAsync(string exclusiveStartTableName, AmazonServiceCallback callback, AsyncOptions options = null)
{
var request = new ListTablesRequest();
request.ExclusiveStartTableName = exclusiveStartTableName;
ListTablesAsync(request, callback, options);
}
///
/// Returns an array of table names associated with the current account and endpoint.
/// The output from ListTables is paginated, with each page returning a maximum
/// of 100 table names.
///
/// The first table name that this operation will evaluate. Use the value that was returned for LastEvaluatedTableName in a previous operation, so that you can obtain the next page of results.
/// A maximum number of table names to return. If this parameter is not specified, the limit is 100.
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the ListTables service method, as returned by DynamoDB.
///
/// An error occurred on the server side.
///
/// REST API Reference for ListTables Operation
public virtual void ListTablesAsync(string exclusiveStartTableName, int limit, AmazonServiceCallback callback, AsyncOptions options = null)
{
var request = new ListTablesRequest();
request.ExclusiveStartTableName = exclusiveStartTableName;
request.Limit = limit;
ListTablesAsync(request, callback, options);
}
///
/// Returns an array of table names associated with the current account and endpoint.
/// The output from ListTables is paginated, with each page returning a maximum
/// of 100 table names.
///
/// A maximum number of table names to return. If this parameter is not specified, the limit is 100.
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the ListTables service method, as returned by DynamoDB.
///
/// An error occurred on the server side.
///
/// REST API Reference for ListTables Operation
public virtual void ListTablesAsync(int limit, AmazonServiceCallback callback, AsyncOptions options = null)
{
var request = new ListTablesRequest();
request.Limit = limit;
ListTablesAsync(request, callback, options);
}
///
/// Initiates the asynchronous execution of the ListTables operation.
///
///
/// Container for the necessary parameters to execute the ListTables operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for ListTables Operation
public virtual void ListTablesAsync(ListTablesRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = ListTablesRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = ListTablesResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = ListTablesEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((ListTablesRequest)req, (ListTablesResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region ListTagsOfResource
internal virtual ListTagsOfResourceResponse ListTagsOfResource(ListTagsOfResourceRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ListTagsOfResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = ListTagsOfResourceResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = ListTagsOfResourceEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the ListTagsOfResource operation.
///
///
/// Container for the necessary parameters to execute the ListTagsOfResource operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for ListTagsOfResource Operation
public virtual void ListTagsOfResourceAsync(ListTagsOfResourceRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = ListTagsOfResourceRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = ListTagsOfResourceResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = ListTagsOfResourceEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((ListTagsOfResourceRequest)req, (ListTagsOfResourceResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region PutItem
internal virtual PutItemResponse PutItem(PutItemRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = PutItemRequestMarshaller.Instance;
options.ResponseUnmarshaller = PutItemResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = PutItemEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Creates a new item, or replaces an old item with a new item. If an item that has the
/// same primary key as the new item already exists in the specified table, the new item
/// completely replaces the existing item. You can perform a conditional put operation
/// (add a new item if one with the specified primary key doesn't exist), or replace an
/// existing item if it has certain attribute values. You can return the item's attribute
/// values in the same operation, using the ReturnValues parameter.
///
///
///
/// This topic provides general information about the PutItem API.
///
///
///
/// For information on how to call the PutItem API using the AWS SDK in specific
/// languages, see the following:
///
///
///
/// When you add an item, the primary key attributes are the only required attributes.
/// Attribute values cannot be null. String and Binary type attributes must have lengths
/// greater than zero. Set type attributes cannot be empty. Requests with empty values
/// will be rejected with a ValidationException exception.
///
///
///
/// To prevent a new item from replacing an existing item, use a conditional expression
/// that contains the attribute_not_exists function with the name of the
/// attribute being used as the partition key for the table. Since every record must contain
/// that attribute, the attribute_not_exists function will only succeed if
/// no matching item exists.
///
///
///
/// For more information about PutItem, see Working
/// with Items in the Amazon DynamoDB Developer Guide.
///
///
/// The name of the table to contain the item.
/// A map of attribute name/value pairs, one for each attribute. Only the primary key attributes are required; you can optionally provide other attribute name-value pairs for the item. You must provide all of the attributes for the primary key. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide both values for both the partition key and the sort key. If you specify any attributes that are part of an index key, then the data types for those attributes must match those of the schema in the table's attribute definition. For more information about primary keys, see Primary Key in the Amazon DynamoDB Developer Guide. Each element in the Item map is an AttributeValue object.
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the PutItem service method, as returned by DynamoDB.
///
/// A condition specified in the operation could not be evaluated.
///
///
/// An error occurred on the server side.
///
///
/// An item collection is too large. This exception is only returned for tables that have
/// one or more local secondary indexes.
///
///
/// Your request rate is too high. The AWS SDKs for DynamoDB automatically retry requests
/// that receive this exception. Your request is eventually successful, unless your retry
/// queue is too large to finish. Reduce the frequency of requests and use exponential
/// backoff. For more information, go to Error
/// Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
///
///
/// Throughput exceeds the current throughput limit for your account. Please contact AWS
/// Support at AWS Support to request a limit
/// increase.
///
///
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be ACTIVE.
///
///
/// Operation was rejected because there is an ongoing transaction for the item.
///
/// REST API Reference for PutItem Operation
public virtual void PutItemAsync(string tableName, Dictionary item, AmazonServiceCallback callback, AsyncOptions options = null)
{
var request = new PutItemRequest();
request.TableName = tableName;
request.Item = item;
PutItemAsync(request, callback, options);
}
///
/// Creates a new item, or replaces an old item with a new item. If an item that has the
/// same primary key as the new item already exists in the specified table, the new item
/// completely replaces the existing item. You can perform a conditional put operation
/// (add a new item if one with the specified primary key doesn't exist), or replace an
/// existing item if it has certain attribute values. You can return the item's attribute
/// values in the same operation, using the ReturnValues parameter.
///
///
///
/// This topic provides general information about the PutItem API.
///
///
///
/// For information on how to call the PutItem API using the AWS SDK in specific
/// languages, see the following:
///
///
///
/// When you add an item, the primary key attributes are the only required attributes.
/// Attribute values cannot be null. String and Binary type attributes must have lengths
/// greater than zero. Set type attributes cannot be empty. Requests with empty values
/// will be rejected with a ValidationException exception.
///
///
///
/// To prevent a new item from replacing an existing item, use a conditional expression
/// that contains the attribute_not_exists function with the name of the
/// attribute being used as the partition key for the table. Since every record must contain
/// that attribute, the attribute_not_exists function will only succeed if
/// no matching item exists.
///
///
///
/// For more information about PutItem, see Working
/// with Items in the Amazon DynamoDB Developer Guide.
///
///
/// The name of the table to contain the item.
/// A map of attribute name/value pairs, one for each attribute. Only the primary key attributes are required; you can optionally provide other attribute name-value pairs for the item. You must provide all of the attributes for the primary key. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide both values for both the partition key and the sort key. If you specify any attributes that are part of an index key, then the data types for those attributes must match those of the schema in the table's attribute definition. For more information about primary keys, see Primary Key in the Amazon DynamoDB Developer Guide. Each element in the Item map is an AttributeValue object.
/// Use ReturnValues if you want to get the item attributes as they appeared before they were updated with the PutItem request. For PutItem, the valid values are: -
NONE - If ReturnValues is not specified, or if its value is NONE, then nothing is returned. (This setting is the default for ReturnValues.) -
ALL_OLD - If PutItem overwrote an attribute name-value pair, then the content of the old item is returned.
The ReturnValues parameter is used by several DynamoDB operations; however, PutItem does not recognize any values other than NONE or ALL_OLD.
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the PutItem service method, as returned by DynamoDB.
///
/// A condition specified in the operation could not be evaluated.
///
///
/// An error occurred on the server side.
///
///
/// An item collection is too large. This exception is only returned for tables that have
/// one or more local secondary indexes.
///
///
/// Your request rate is too high. The AWS SDKs for DynamoDB automatically retry requests
/// that receive this exception. Your request is eventually successful, unless your retry
/// queue is too large to finish. Reduce the frequency of requests and use exponential
/// backoff. For more information, go to Error
/// Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
///
///
/// Throughput exceeds the current throughput limit for your account. Please contact AWS
/// Support at AWS Support to request a limit
/// increase.
///
///
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be ACTIVE.
///
///
/// Operation was rejected because there is an ongoing transaction for the item.
///
/// REST API Reference for PutItem Operation
public virtual void PutItemAsync(string tableName, Dictionary item, ReturnValue returnValues, AmazonServiceCallback callback, AsyncOptions options = null)
{
var request = new PutItemRequest();
request.TableName = tableName;
request.Item = item;
request.ReturnValues = returnValues;
PutItemAsync(request, callback, options);
}
///
/// Initiates the asynchronous execution of the PutItem operation.
///
///
/// Container for the necessary parameters to execute the PutItem operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for PutItem Operation
public virtual void PutItemAsync(PutItemRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = PutItemRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = PutItemResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = PutItemEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((PutItemRequest)req, (PutItemResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region Query
internal virtual QueryResponse Query(QueryRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = QueryRequestMarshaller.Instance;
options.ResponseUnmarshaller = QueryResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = QueryEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the Query operation.
///
///
/// Container for the necessary parameters to execute the Query operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for Query Operation
public virtual void QueryAsync(QueryRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = QueryRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = QueryResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = QueryEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((QueryRequest)req, (QueryResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region RestoreTableFromBackup
internal virtual RestoreTableFromBackupResponse RestoreTableFromBackup(RestoreTableFromBackupRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = RestoreTableFromBackupRequestMarshaller.Instance;
options.ResponseUnmarshaller = RestoreTableFromBackupResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = RestoreTableFromBackupEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the RestoreTableFromBackup operation.
///
///
/// Container for the necessary parameters to execute the RestoreTableFromBackup operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for RestoreTableFromBackup Operation
public virtual void RestoreTableFromBackupAsync(RestoreTableFromBackupRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = RestoreTableFromBackupRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = RestoreTableFromBackupResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = RestoreTableFromBackupEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((RestoreTableFromBackupRequest)req, (RestoreTableFromBackupResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region RestoreTableToPointInTime
internal virtual RestoreTableToPointInTimeResponse RestoreTableToPointInTime(RestoreTableToPointInTimeRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = RestoreTableToPointInTimeRequestMarshaller.Instance;
options.ResponseUnmarshaller = RestoreTableToPointInTimeResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = RestoreTableToPointInTimeEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the RestoreTableToPointInTime operation.
///
///
/// Container for the necessary parameters to execute the RestoreTableToPointInTime operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for RestoreTableToPointInTime Operation
public virtual void RestoreTableToPointInTimeAsync(RestoreTableToPointInTimeRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = RestoreTableToPointInTimeRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = RestoreTableToPointInTimeResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = RestoreTableToPointInTimeEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((RestoreTableToPointInTimeRequest)req, (RestoreTableToPointInTimeResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region Scan
internal virtual ScanResponse Scan(ScanRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = ScanRequestMarshaller.Instance;
options.ResponseUnmarshaller = ScanResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = ScanEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// The Scan operation returns one or more items and item attributes by accessing
/// every item in a table or a secondary index. To have DynamoDB return fewer items, you
/// can provide a FilterExpression operation.
///
///
///
/// If the total number of scanned items exceeds the maximum dataset size limit of 1 MB,
/// the scan stops and results are returned to the user as a LastEvaluatedKey
/// value to continue the scan in a subsequent operation. The results also include the
/// number of items exceeding the limit. A scan can result in no table data meeting the
/// filter criteria.
///
///
///
/// A single Scan operation reads up to the maximum number of items set (if
/// using the Limit parameter) or a maximum of 1 MB of data and then apply
/// any filtering to the results using FilterExpression. If LastEvaluatedKey
/// is present in the response, you need to paginate the result set. For more information,
/// see Paginating
/// the Results in the Amazon DynamoDB Developer Guide.
///
///
///
/// Scan operations proceed sequentially; however, for faster performance
/// on a large table or secondary index, applications can request a parallel Scan
/// operation by providing the Segment and TotalSegments parameters.
/// For more information, see Parallel
/// Scan in the Amazon DynamoDB Developer Guide.
///
///
///
/// Scan uses eventually consistent reads when accessing the data in a table;
/// therefore, the result set might not include the changes to data in the table immediately
/// before the operation began. If you need a consistent copy of the data, as of the time
/// that the Scan begins, you can set the ConsistentRead parameter
/// to true.
///
///
/// The name of the table containing the requested items; or, if you provide IndexName, the name of the table to which that index belongs.
/// This is a legacy parameter. Use ProjectionExpression instead. For more information, see AttributesToGet in the Amazon DynamoDB Developer Guide.
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the Scan service method, as returned by DynamoDB.
///
/// An error occurred on the server side.
///
///
/// Your request rate is too high. The AWS SDKs for DynamoDB automatically retry requests
/// that receive this exception. Your request is eventually successful, unless your retry
/// queue is too large to finish. Reduce the frequency of requests and use exponential
/// backoff. For more information, go to Error
/// Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
///
///
/// Throughput exceeds the current throughput limit for your account. Please contact AWS
/// Support at AWS Support to request a limit
/// increase.
///
///
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be ACTIVE.
///
/// REST API Reference for Scan Operation
public virtual void ScanAsync(string tableName, List attributesToGet, AmazonServiceCallback callback, AsyncOptions options = null)
{
var request = new ScanRequest();
request.TableName = tableName;
request.AttributesToGet = attributesToGet;
ScanAsync(request, callback, options);
}
///
/// The Scan operation returns one or more items and item attributes by accessing
/// every item in a table or a secondary index. To have DynamoDB return fewer items, you
/// can provide a FilterExpression operation.
///
///
///
/// If the total number of scanned items exceeds the maximum dataset size limit of 1 MB,
/// the scan stops and results are returned to the user as a LastEvaluatedKey
/// value to continue the scan in a subsequent operation. The results also include the
/// number of items exceeding the limit. A scan can result in no table data meeting the
/// filter criteria.
///
///
///
/// A single Scan operation reads up to the maximum number of items set (if
/// using the Limit parameter) or a maximum of 1 MB of data and then apply
/// any filtering to the results using FilterExpression. If LastEvaluatedKey
/// is present in the response, you need to paginate the result set. For more information,
/// see Paginating
/// the Results in the Amazon DynamoDB Developer Guide.
///
///
///
/// Scan operations proceed sequentially; however, for faster performance
/// on a large table or secondary index, applications can request a parallel Scan
/// operation by providing the Segment and TotalSegments parameters.
/// For more information, see Parallel
/// Scan in the Amazon DynamoDB Developer Guide.
///
///
///
/// Scan uses eventually consistent reads when accessing the data in a table;
/// therefore, the result set might not include the changes to data in the table immediately
/// before the operation began. If you need a consistent copy of the data, as of the time
/// that the Scan begins, you can set the ConsistentRead parameter
/// to true.
///
///
/// The name of the table containing the requested items; or, if you provide IndexName, the name of the table to which that index belongs.
/// This is a legacy parameter. Use FilterExpression instead. For more information, see ScanFilter in the Amazon DynamoDB Developer Guide.
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the Scan service method, as returned by DynamoDB.
///
/// An error occurred on the server side.
///
///
/// Your request rate is too high. The AWS SDKs for DynamoDB automatically retry requests
/// that receive this exception. Your request is eventually successful, unless your retry
/// queue is too large to finish. Reduce the frequency of requests and use exponential
/// backoff. For more information, go to Error
/// Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
///
///
/// Throughput exceeds the current throughput limit for your account. Please contact AWS
/// Support at AWS Support to request a limit
/// increase.
///
///
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be ACTIVE.
///
/// REST API Reference for Scan Operation
public virtual void ScanAsync(string tableName, Dictionary scanFilter, AmazonServiceCallback callback, AsyncOptions options = null)
{
var request = new ScanRequest();
request.TableName = tableName;
request.ScanFilter = scanFilter;
ScanAsync(request, callback, options);
}
///
/// The Scan operation returns one or more items and item attributes by accessing
/// every item in a table or a secondary index. To have DynamoDB return fewer items, you
/// can provide a FilterExpression operation.
///
///
///
/// If the total number of scanned items exceeds the maximum dataset size limit of 1 MB,
/// the scan stops and results are returned to the user as a LastEvaluatedKey
/// value to continue the scan in a subsequent operation. The results also include the
/// number of items exceeding the limit. A scan can result in no table data meeting the
/// filter criteria.
///
///
///
/// A single Scan operation reads up to the maximum number of items set (if
/// using the Limit parameter) or a maximum of 1 MB of data and then apply
/// any filtering to the results using FilterExpression. If LastEvaluatedKey
/// is present in the response, you need to paginate the result set. For more information,
/// see Paginating
/// the Results in the Amazon DynamoDB Developer Guide.
///
///
///
/// Scan operations proceed sequentially; however, for faster performance
/// on a large table or secondary index, applications can request a parallel Scan
/// operation by providing the Segment and TotalSegments parameters.
/// For more information, see Parallel
/// Scan in the Amazon DynamoDB Developer Guide.
///
///
///
/// Scan uses eventually consistent reads when accessing the data in a table;
/// therefore, the result set might not include the changes to data in the table immediately
/// before the operation began. If you need a consistent copy of the data, as of the time
/// that the Scan begins, you can set the ConsistentRead parameter
/// to true.
///
///
/// The name of the table containing the requested items; or, if you provide IndexName, the name of the table to which that index belongs.
/// This is a legacy parameter. Use ProjectionExpression instead. For more information, see AttributesToGet in the Amazon DynamoDB Developer Guide.
/// This is a legacy parameter. Use FilterExpression instead. For more information, see ScanFilter in the Amazon DynamoDB Developer Guide.
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the Scan service method, as returned by DynamoDB.
///
/// An error occurred on the server side.
///
///
/// Your request rate is too high. The AWS SDKs for DynamoDB automatically retry requests
/// that receive this exception. Your request is eventually successful, unless your retry
/// queue is too large to finish. Reduce the frequency of requests and use exponential
/// backoff. For more information, go to Error
/// Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
///
///
/// Throughput exceeds the current throughput limit for your account. Please contact AWS
/// Support at AWS Support to request a limit
/// increase.
///
///
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be ACTIVE.
///
/// REST API Reference for Scan Operation
public virtual void ScanAsync(string tableName, List attributesToGet, Dictionary scanFilter, AmazonServiceCallback callback, AsyncOptions options = null)
{
var request = new ScanRequest();
request.TableName = tableName;
request.AttributesToGet = attributesToGet;
request.ScanFilter = scanFilter;
ScanAsync(request, callback, options);
}
///
/// Initiates the asynchronous execution of the Scan operation.
///
///
/// Container for the necessary parameters to execute the Scan operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for Scan Operation
public virtual void ScanAsync(ScanRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = ScanRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = ScanResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = ScanEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((ScanRequest)req, (ScanResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region TagResource
internal virtual TagResourceResponse TagResource(TagResourceRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = TagResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = TagResourceEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the TagResource operation.
///
///
/// Container for the necessary parameters to execute the TagResource operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for TagResource Operation
public virtual void TagResourceAsync(TagResourceRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = TagResourceRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = TagResourceEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((TagResourceRequest)req, (TagResourceResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region TransactGetItems
internal virtual TransactGetItemsResponse TransactGetItems(TransactGetItemsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = TransactGetItemsRequestMarshaller.Instance;
options.ResponseUnmarshaller = TransactGetItemsResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = TransactGetItemsEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the TransactGetItems operation.
///
///
/// Container for the necessary parameters to execute the TransactGetItems operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for TransactGetItems Operation
public virtual void TransactGetItemsAsync(TransactGetItemsRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = TransactGetItemsRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = TransactGetItemsResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = TransactGetItemsEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((TransactGetItemsRequest)req, (TransactGetItemsResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region TransactWriteItems
internal virtual TransactWriteItemsResponse TransactWriteItems(TransactWriteItemsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = TransactWriteItemsRequestMarshaller.Instance;
options.ResponseUnmarshaller = TransactWriteItemsResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = TransactWriteItemsEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the TransactWriteItems operation.
///
///
/// Container for the necessary parameters to execute the TransactWriteItems operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for TransactWriteItems Operation
public virtual void TransactWriteItemsAsync(TransactWriteItemsRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = TransactWriteItemsRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = TransactWriteItemsResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = TransactWriteItemsEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((TransactWriteItemsRequest)req, (TransactWriteItemsResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region UntagResource
internal virtual UntagResourceResponse UntagResource(UntagResourceRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UntagResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = UntagResourceEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the UntagResource operation.
///
///
/// Container for the necessary parameters to execute the UntagResource operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for UntagResource Operation
public virtual void UntagResourceAsync(UntagResourceRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = UntagResourceRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = UntagResourceEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((UntagResourceRequest)req, (UntagResourceResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region UpdateContinuousBackups
internal virtual UpdateContinuousBackupsResponse UpdateContinuousBackups(UpdateContinuousBackupsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateContinuousBackupsRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateContinuousBackupsResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = UpdateContinuousBackupsEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the UpdateContinuousBackups operation.
///
///
/// Container for the necessary parameters to execute the UpdateContinuousBackups operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for UpdateContinuousBackups Operation
public virtual void UpdateContinuousBackupsAsync(UpdateContinuousBackupsRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = UpdateContinuousBackupsRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = UpdateContinuousBackupsResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = UpdateContinuousBackupsEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((UpdateContinuousBackupsRequest)req, (UpdateContinuousBackupsResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region UpdateContributorInsights
internal virtual UpdateContributorInsightsResponse UpdateContributorInsights(UpdateContributorInsightsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateContributorInsightsRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateContributorInsightsResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the UpdateContributorInsights operation.
///
///
/// Container for the necessary parameters to execute the UpdateContributorInsights operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for UpdateContributorInsights Operation
public virtual void UpdateContributorInsightsAsync(UpdateContributorInsightsRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = UpdateContributorInsightsRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = UpdateContributorInsightsResponseUnmarshaller.Instance;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((UpdateContributorInsightsRequest)req, (UpdateContributorInsightsResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region UpdateGlobalTable
internal virtual UpdateGlobalTableResponse UpdateGlobalTable(UpdateGlobalTableRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateGlobalTableRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateGlobalTableResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = UpdateGlobalTableEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the UpdateGlobalTable operation.
///
///
/// Container for the necessary parameters to execute the UpdateGlobalTable operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for UpdateGlobalTable Operation
public virtual void UpdateGlobalTableAsync(UpdateGlobalTableRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = UpdateGlobalTableRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = UpdateGlobalTableResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = UpdateGlobalTableEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((UpdateGlobalTableRequest)req, (UpdateGlobalTableResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region UpdateGlobalTableSettings
internal virtual UpdateGlobalTableSettingsResponse UpdateGlobalTableSettings(UpdateGlobalTableSettingsRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateGlobalTableSettingsRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateGlobalTableSettingsResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = UpdateGlobalTableSettingsEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the UpdateGlobalTableSettings operation.
///
///
/// Container for the necessary parameters to execute the UpdateGlobalTableSettings operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for UpdateGlobalTableSettings Operation
public virtual void UpdateGlobalTableSettingsAsync(UpdateGlobalTableSettingsRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = UpdateGlobalTableSettingsRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = UpdateGlobalTableSettingsResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = UpdateGlobalTableSettingsEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((UpdateGlobalTableSettingsRequest)req, (UpdateGlobalTableSettingsResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region UpdateItem
internal virtual UpdateItemResponse UpdateItem(UpdateItemRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateItemRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateItemResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = UpdateItemEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Edits an existing item's attributes, or adds a new item to the table if it does not
/// already exist. You can put, delete, or add attribute values. You can also perform
/// a conditional update on an existing item (insert a new attribute name-value pair if
/// it doesn't exist, or replace an existing name-value pair if it has certain expected
/// attribute values).
///
///
///
/// You can also return the item's attribute values in the same UpdateItem
/// operation using the ReturnValues parameter.
///
///
/// The name of the table containing the item to update.
/// The primary key of the item to be updated. Each element consists of an attribute name and a value for that attribute. For the primary key, you must provide all of the attributes. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide values for both the partition key and the sort key.
/// This is a legacy parameter. Use UpdateExpression instead. For more information, see AttributeUpdates in the Amazon DynamoDB Developer Guide.
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the UpdateItem service method, as returned by DynamoDB.
///
/// A condition specified in the operation could not be evaluated.
///
///
/// An error occurred on the server side.
///
///
/// An item collection is too large. This exception is only returned for tables that have
/// one or more local secondary indexes.
///
///
/// Your request rate is too high. The AWS SDKs for DynamoDB automatically retry requests
/// that receive this exception. Your request is eventually successful, unless your retry
/// queue is too large to finish. Reduce the frequency of requests and use exponential
/// backoff. For more information, go to Error
/// Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
///
///
/// Throughput exceeds the current throughput limit for your account. Please contact AWS
/// Support at AWS Support to request a limit
/// increase.
///
///
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be ACTIVE.
///
///
/// Operation was rejected because there is an ongoing transaction for the item.
///
/// REST API Reference for UpdateItem Operation
public virtual void UpdateItemAsync(string tableName, Dictionary key, Dictionary attributeUpdates, AmazonServiceCallback callback, AsyncOptions options = null)
{
var request = new UpdateItemRequest();
request.TableName = tableName;
request.Key = key;
request.AttributeUpdates = attributeUpdates;
UpdateItemAsync(request, callback, options);
}
///
/// Edits an existing item's attributes, or adds a new item to the table if it does not
/// already exist. You can put, delete, or add attribute values. You can also perform
/// a conditional update on an existing item (insert a new attribute name-value pair if
/// it doesn't exist, or replace an existing name-value pair if it has certain expected
/// attribute values).
///
///
///
/// You can also return the item's attribute values in the same UpdateItem
/// operation using the ReturnValues parameter.
///
///
/// The name of the table containing the item to update.
/// The primary key of the item to be updated. Each element consists of an attribute name and a value for that attribute. For the primary key, you must provide all of the attributes. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide values for both the partition key and the sort key.
/// This is a legacy parameter. Use UpdateExpression instead. For more information, see AttributeUpdates in the Amazon DynamoDB Developer Guide.
/// Use ReturnValues if you want to get the item attributes as they appear before or after they are updated. For UpdateItem, the valid values are: -
NONE - If ReturnValues is not specified, or if its value is NONE, then nothing is returned. (This setting is the default for ReturnValues.) -
ALL_OLD - Returns all of the attributes of the item, as they appeared before the UpdateItem operation. -
UPDATED_OLD - Returns only the updated attributes, as they appeared before the UpdateItem operation. -
ALL_NEW - Returns all of the attributes of the item, as they appear after the UpdateItem operation. -
UPDATED_NEW - Returns only the updated attributes, as they appear after the UpdateItem operation.
There is no additional cost associated with requesting a return value aside from the small network and processing overhead of receiving a larger response. No read capacity units are consumed. The values returned are strongly consistent.
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the UpdateItem service method, as returned by DynamoDB.
///
/// A condition specified in the operation could not be evaluated.
///
///
/// An error occurred on the server side.
///
///
/// An item collection is too large. This exception is only returned for tables that have
/// one or more local secondary indexes.
///
///
/// Your request rate is too high. The AWS SDKs for DynamoDB automatically retry requests
/// that receive this exception. Your request is eventually successful, unless your retry
/// queue is too large to finish. Reduce the frequency of requests and use exponential
/// backoff. For more information, go to Error
/// Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
///
///
/// Throughput exceeds the current throughput limit for your account. Please contact AWS
/// Support at AWS Support to request a limit
/// increase.
///
///
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be ACTIVE.
///
///
/// Operation was rejected because there is an ongoing transaction for the item.
///
/// REST API Reference for UpdateItem Operation
public virtual void UpdateItemAsync(string tableName, Dictionary key, Dictionary attributeUpdates, ReturnValue returnValues, AmazonServiceCallback callback, AsyncOptions options = null)
{
var request = new UpdateItemRequest();
request.TableName = tableName;
request.Key = key;
request.AttributeUpdates = attributeUpdates;
request.ReturnValues = returnValues;
UpdateItemAsync(request, callback, options);
}
///
/// Initiates the asynchronous execution of the UpdateItem operation.
///
///
/// Container for the necessary parameters to execute the UpdateItem operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for UpdateItem Operation
public virtual void UpdateItemAsync(UpdateItemRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = UpdateItemRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = UpdateItemResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = UpdateItemEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((UpdateItemRequest)req, (UpdateItemResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region UpdateTable
internal virtual UpdateTableResponse UpdateTable(UpdateTableRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateTableRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateTableResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = UpdateTableEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Modifies the provisioned throughput settings, global secondary indexes, or DynamoDB
/// Streams settings for a given table.
///
///
///
/// You can only perform one of the following operations at once:
///
/// -
///
/// Modify the provisioned throughput settings of the table.
///
///
-
///
/// Enable or disable DynamoDB Streams on the table.
///
///
-
///
/// Remove a global secondary index from the table.
///
///
-
///
/// Create a new global secondary index on the table. After the index begins backfilling,
/// you can use
UpdateTable to perform other operations.
///
///
///
/// UpdateTable is an asynchronous operation; while it is executing, the
/// table status changes from ACTIVE to UPDATING. While it is
/// UPDATING, you cannot issue another UpdateTable request.
/// When the table returns to the ACTIVE state, the UpdateTable
/// operation is complete.
///
///
/// The name of the table to be updated.
/// The new provisioned throughput settings for the specified table or index.
/// An Action delegate that is invoked when the operation completes.
///
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
///
///
/// The response from the UpdateTable service method, as returned by DynamoDB.
///
/// An error occurred on the server side.
///
///
/// There is no limit to the number of daily on-demand backups that can be taken.
///
///
///
/// Up to 50 simultaneous table operations are allowed per account. These operations include
/// CreateTable, UpdateTable, DeleteTable,UpdateTimeToLive,
/// RestoreTableFromBackup, and RestoreTableToPointInTime.
///
///
///
/// The only exception is when you are creating a table with one or more secondary indexes.
/// You can have up to 25 such requests running at a time; however, if the table or index
/// specifications are complex, DynamoDB might temporarily reduce the number of concurrent
/// operations.
///
///
///
/// There is a soft account limit of 256 tables.
///
///
///
/// The operation conflicts with the resource's availability. For example, you attempted
/// to recreate an existing table, or tried to delete a table currently in the CREATING
/// state.
///
///
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be ACTIVE.
///
/// REST API Reference for UpdateTable Operation
public virtual void UpdateTableAsync(string tableName, ProvisionedThroughput provisionedThroughput, AmazonServiceCallback callback, AsyncOptions options = null)
{
var request = new UpdateTableRequest();
request.TableName = tableName;
request.ProvisionedThroughput = provisionedThroughput;
UpdateTableAsync(request, callback, options);
}
///
/// Initiates the asynchronous execution of the UpdateTable operation.
///
///
/// Container for the necessary parameters to execute the UpdateTable operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for UpdateTable Operation
public virtual void UpdateTableAsync(UpdateTableRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = UpdateTableRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = UpdateTableResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = UpdateTableEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((UpdateTableRequest)req, (UpdateTableResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region UpdateTableReplicaAutoScaling
internal virtual UpdateTableReplicaAutoScalingResponse UpdateTableReplicaAutoScaling(UpdateTableReplicaAutoScalingRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateTableReplicaAutoScalingRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateTableReplicaAutoScalingResponseUnmarshaller.Instance;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the UpdateTableReplicaAutoScaling operation.
///
///
/// Container for the necessary parameters to execute the UpdateTableReplicaAutoScaling operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for UpdateTableReplicaAutoScaling Operation
public virtual void UpdateTableReplicaAutoScalingAsync(UpdateTableReplicaAutoScalingRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = UpdateTableReplicaAutoScalingRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = UpdateTableReplicaAutoScalingResponseUnmarshaller.Instance;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((UpdateTableReplicaAutoScalingRequest)req, (UpdateTableReplicaAutoScalingResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
#region UpdateTimeToLive
internal virtual UpdateTimeToLiveResponse UpdateTimeToLive(UpdateTimeToLiveRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateTimeToLiveRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateTimeToLiveResponseUnmarshaller.Instance;
options.EndpointDiscoveryMarshaller = UpdateTimeToLiveEndpointDiscoveryMarshaller.Instance;
options.EndpointOperation = EndpointOperation;
return Invoke(request, options);
}
///
/// Initiates the asynchronous execution of the UpdateTimeToLive operation.
///
///
/// Container for the necessary parameters to execute the UpdateTimeToLive operation on AmazonDynamoDBClient.
/// An Action delegate that is invoked when the operation completes.
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// REST API Reference for UpdateTimeToLive Operation
public virtual void UpdateTimeToLiveAsync(UpdateTimeToLiveRequest request, AmazonServiceCallback callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var invokeOptions = new InvokeOptions();
invokeOptions.RequestMarshaller = UpdateTimeToLiveRequestMarshaller.Instance;
invokeOptions.ResponseUnmarshaller = UpdateTimeToLiveResponseUnmarshaller.Instance;
invokeOptions.EndpointDiscoveryMarshaller = UpdateTimeToLiveEndpointDiscoveryMarshaller.Instance;
invokeOptions.EndpointOperation = EndpointOperation;
Action callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult responseObject
= new AmazonServiceResult((UpdateTimeToLiveRequest)req, (UpdateTimeToLiveResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke(request, invokeOptions, options, callbackHelper);
}
#endregion
}
}