internal BatchWriteItemResponse BatchWriteItem(BatchWriteItemRequest request)
{
var marshaller = new BatchWriteItemRequestMarshaller();
var unmarshaller = BatchWriteItemResponseUnmarshaller.Instance;
return Invoke<BatchWriteItemRequest,BatchWriteItemResponse>(request, marshaller, unmarshaller);
}
/// <summary>
/// Initiates the asynchronous execution of the BatchWriteItem operation.
/// <seealso cref="Amazon.DynamoDBv2.IAmazonDynamoDB"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the BatchWriteItem operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task<BatchWriteItemResponse> BatchWriteItemAsync(BatchWriteItemRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new BatchWriteItemRequestMarshaller();
var unmarshaller = BatchWriteItemResponseUnmarshaller.Instance;
return InvokeAsync<BatchWriteItemRequest,BatchWriteItemResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
/// <summary>
/// Initiates the asynchronous execution of the BatchWriteItem operation.
/// <seealso cref="Amazon.DynamoDBv2.AmazonDynamoDB.BatchWriteItem"/>
/// </summary>
///
/// <param name="batchWriteItemRequest">Container for the necessary parameters to execute the BatchWriteItem operation on
/// AmazonDynamoDBv2.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndBatchWriteItem
/// operation.</returns>
public IAsyncResult BeginBatchWriteItem(BatchWriteItemRequest batchWriteItemRequest, AsyncCallback callback, object state)
{
return invokeBatchWriteItem(batchWriteItemRequest, callback, state, false);
}
IAsyncResult invokeBatchWriteItem(BatchWriteItemRequest batchWriteItemRequest, AsyncCallback callback, object state, bool synchronized)
{
IRequest irequest = new BatchWriteItemRequestMarshaller().Marshall(batchWriteItemRequest);
var unmarshaller = BatchWriteItemResponseUnmarshaller.GetInstance();
AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller);
Invoke(result);
return result;
}
/// <summary>
/// The <i>BatchWriteItem</i> operation puts or deletes multiple items in one or more
/// tables. A single call to <i>BatchWriteItem</i> 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.
///
/// <note>
/// <para>
/// <i>BatchWriteItem</i> cannot update items. To update items, use the <i>UpdateItem</i>
/// API.
/// </para>
/// </note>
/// <para>
/// The individual <i>PutItem</i> and <i>DeleteItem</i> operations specified in <i>BatchWriteItem</i>
/// are atomic; however <i>BatchWriteItem</i> 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 <i>UnprocessedItems</i>
/// response parameter. You can investigate and optionally resend the requests. Typically,
/// you would call <i>BatchWriteItem</i> in a loop. Each iteration would check for unprocessed
/// items and submit a new <i>BatchWriteItem</i> request with those unprocessed items
/// until all items have been processed.
/// </para>
///
/// <para>
/// Note that if <i>none</i> of the items can be processed due to insufficient provisioned
/// throughput on all of the tables in the request, then <i>BatchWriteItem</i> will return
/// a <i>ProvisionedThroughputExceededException</i>.
/// </para>
/// <important>
/// <para>
/// If DynamoDB returns any unprocessed items, you should retry the batch operation on
/// those items. However, <i>we strongly recommend that you use an exponential backoff
/// algorithm</i>. 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.
/// </para>
///
/// <para>
/// For more information, see <a href="http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#BatchOperations">Batch
/// Operations and Error Handling</a> in the <i>Amazon DynamoDB Developer Guide</i>.
/// </para>
/// </important>
/// <para>
/// With <i>BatchWriteItem</i>, you can efficiently write or delete large amounts of data,
/// such as from Amazon Elastic MapReduce (EMR), or copy data from another database into
/// DynamoDB. In order to improve performance with these large-scale operations, <i>BatchWriteItem</i>
/// does not behave in the same way as individual <i>PutItem</i> and <i>DeleteItem</i>
/// calls would. For example, you cannot specify conditions on individual put and delete
/// requests, and <i>BatchWriteItem</i> does not return deleted items in the response.
/// </para>
///
/// <para>
/// If you use a programming language that supports concurrency, such as Java, 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, such as
/// PHP, you must update or delete the specified items one at a time. In both situations,
/// <i>BatchWriteItem</i> provides an alternative where the API 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.
/// </para>
///
/// <para>
/// 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.
/// </para>
///
/// <para>
/// If one or more of the following is true, DynamoDB rejects the entire batch write operation:
/// </para>
/// <ul> <li>
/// <para>
/// One or more tables specified in the <i>BatchWriteItem</i> request does not exist.
/// </para>
/// </li> <li>
/// <para>
/// Primary key attributes specified on an item in the request do not match those in the
/// corresponding table's primary key schema.
/// </para>
/// </li> <li>
/// <para>
/// You try to perform multiple operations on the same item in the same <i>BatchWriteItem</i>
/// request. For example, you cannot put and delete the same item in the same <i>BatchWriteItem</i>
/// request.
/// </para>
/// </li> <li>
/// <para>
/// There are more than 25 requests in the batch.
/// </para>
/// </li> <li>
/// <para>
/// Any individual item in a batch exceeds 400 KB.
/// </para>
/// </li> <li>
/// <para>
/// The total request size exceeds 16 MB.
/// </para>
/// </li> </ul>
/// </summary>
/// <param name="requestItems">A map of one or more table names and, for each table, a list of operations to be performed (<i>DeleteRequest</i> or <i>PutRequest</i>). Each element in the map consists of the following: <ul> <li> <i>DeleteRequest</i> - Perform a <i>DeleteItem</i> operation on the specified item. The item to be deleted is identified by a <i>Key</i> subelement: <ul> <li> <i>Key</i> - 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 <i>all</i> of the key attributes. For example, with a hash type primary key, you only need to provide the hash attribute. For a hash-and-range type primary key, you must provide <i>both</i> the hash attribute and the range attribute. </li> </ul> </li> <li> <i>PutRequest</i> - Perform a <i>PutItem</i> operation on the specified item. The item to be put is identified by an <i>Item</i> subelement: <ul> <li> <i>Item</i> - 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 will be rejected with a <i>ValidationException</i> 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. </li> </ul> </li> </ul></param>
///
/// <returns>The response from the BatchWriteItem service method, as returned by DynamoDB.</returns>
/// <exception cref="Amazon.DynamoDBv2.Model.InternalServerErrorException">
/// An error occurred on the server side.
/// </exception>
/// <exception cref="Amazon.DynamoDBv2.Model.ItemCollectionSizeLimitExceededException">
/// An item collection is too large. This exception is only returned for tables that have
/// one or more local secondary indexes.
/// </exception>
/// <exception cref="Amazon.DynamoDBv2.Model.ProvisionedThroughputExceededException">
/// The request rate is too high, or the request is too large, for the available throughput
/// to accommodate. The AWS SDKs automatically retry requests that receive this exception;
/// therefore, your request will eventually succeed, unless the request is too large or
/// your retry queue is too large to finish. Reduce the frequency of requests by using
/// the strategies listed in <a href="http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#APIRetries">Error
/// Retries and Exponential Backoff</a> in the <i>Amazon DynamoDB Developer Guide</i>.
/// </exception>
/// <exception cref="Amazon.DynamoDBv2.Model.ResourceNotFoundException">
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be <code>ACTIVE</code>.
/// </exception>
public BatchWriteItemResponse BatchWriteItem(Dictionary<string, List<WriteRequest>> requestItems)
{
var request = new BatchWriteItemRequest();
request.RequestItems = requestItems;
return BatchWriteItem(request);
}
/// <summary>
/// <para>The <i>BatchWriteItem</i> operation puts or deletes multiple items in one or more tables. A single call to <i>BatchWriteItem</i> can
/// write up to 1 MB of data, which can comprise as many as 25 put or delete requests. Individual items to be written can be as large as 64
/// KB.</para> <para><b>NOTE:</b> BatchWriteItem cannot update items. To update items, use the UpdateItem API. </para> <para>The individual
/// <i>PutItem</i> and <i>DeleteItem</i> operations specified in <i>BatchWriteItem</i> are atomic; however <i>BatchWriteItem</i> 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 <i>UnprocessedItems</i> response parameter. You can investigate and optionally resend the requests.
/// Typically, you would call <i>BatchWriteItem</i> in a loop. Each iteration would check for unprocessed items and submit a new
/// <i>BatchWriteItem</i> request with those unprocessed items until all items have been processed.</para> <para>To write one item, you can use
/// the <i>PutItem</i> operation; to delete one item, you can use the <i>DeleteItem</i> operation.</para> <para>With <i>BatchWriteItem</i> , you
/// can efficiently write or delete large amounts of data, such as from Amazon Elastic MapReduce (EMR), or copy data from another database into
/// Amazon DynamoDB. In order to improve performance with these large-scale operations, <i>BatchWriteItem</i> does not behave in the same way as
/// individual <i>PutItem</i> and <i>DeleteItem</i> calls would For example, you cannot specify conditions on individual put and delete
/// requests, and <i>BatchWriteItem</i> does not return deleted items in the response.</para> <para>If you use a programming language that
/// supports concurrency, such as Java, you can use threads to write items in parallel. Your application must include the necessary logic to
/// manage the threads.</para> <para>With languages that don't support threading, such as PHP, <i>BatchWriteItem</i> will write or delete the
/// specified items one at a time. In both situations, <i>BatchWriteItem</i> provides an alternative where the API 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.</para> <para>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.</para>
/// <para>If one or more of the following is true, Amazon DynamoDB rejects the entire batch write operation:</para>
/// <ul>
/// <li> <para>One or more tables specified in the <i>BatchWriteItem</i> request does not exist.</para> </li>
/// <li> <para>Primary key attributes specified on an item in the request do not match those in the corresponding table's primary key
/// schema.</para> </li>
/// <li> <para>You try to perform multiple operations on the same item in the same <i>BatchWriteItem</i> request. For example, you cannot put
/// and delete the same item in the same <i>BatchWriteItem</i> request. </para> </li>
/// <li> <para>The total request size exceeds 1 MB.</para> </li>
/// <li> <para>Any individual item in a batch exceeds 64 KB.</para> </li>
///
/// </ul>
/// </summary>
///
/// <param name="batchWriteItemRequest">Container for the necessary parameters to execute the BatchWriteItem service method on
/// AmazonDynamoDBv2.</param>
///
/// <returns>The response from the BatchWriteItem service method, as returned by AmazonDynamoDBv2.</returns>
///
/// <exception cref="ItemCollectionSizeLimitExceededException"/>
/// <exception cref="ResourceNotFoundException"/>
/// <exception cref="ProvisionedThroughputExceededException"/>
/// <exception cref="InternalServerErrorException"/>
public BatchWriteItemResponse BatchWriteItem(BatchWriteItemRequest batchWriteItemRequest)
{
IAsyncResult asyncResult = invokeBatchWriteItem(batchWriteItemRequest, null, null, true);
return EndBatchWriteItem(asyncResult);
}
internal BatchWriteItemResponse BatchWriteItem(BatchWriteItemRequest request)
{
var task = BatchWriteItemAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return null;
}
}
/// <summary>
/// <para>The <i>BatchWriteItem</i> operation puts or deletes multiple items in one or more tables. A single call to <i>BatchWriteItem</i> can
/// write up to 1 MB of data, which can comprise as many as 25 put or delete requests. Individual items to be written can be as large as 64
/// KB.</para> <para><b>NOTE:</b> BatchWriteItem cannot update items. To update items, use the UpdateItem API. </para> <para>The individual
/// <i>PutItem</i> and <i>DeleteItem</i> operations specified in <i>BatchWriteItem</i> are atomic; however <i>BatchWriteItem</i> 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 <i>UnprocessedItems</i> response parameter. You can investigate and optionally resend the requests.
/// Typically, you would call <i>BatchWriteItem</i> in a loop. Each iteration would check for unprocessed items and submit a new
/// <i>BatchWriteItem</i> request with those unprocessed items until all items have been processed.</para> <para>Note that if <i>none</i> of the
/// items can be processed due to insufficient provisioned throughput on all of the tables in the request, then <i>BatchGetItem</i> will throw a
/// <i>ProvisionedThroughputExceededException</i> .</para> <para>To write one item, you can use the <i>PutItem</i> operation; to delete one
/// item, you can use the <i>DeleteItem</i> operation.</para> <para>With <i>BatchWriteItem</i> , you can efficiently write or delete large
/// amounts of data, such as from Amazon Elastic MapReduce (EMR), or copy data from another database into DynamoDB. In order to improve
/// performance with these large-scale operations, <i>BatchWriteItem</i> does not behave in the same way as individual <i>PutItem</i> and
/// <i>DeleteItem</i> calls would For example, you cannot specify conditions on individual put and delete requests, and <i>BatchWriteItem</i>
/// does not return deleted items in the response.</para> <para>If you use a programming language that supports concurrency, such as Java, 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, such as PHP, you must update or delete the specified items one at a time. In both situations, <i>BatchWriteItem</i>
/// provides an alternative where the API 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.</para> <para>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.</para> <para>If one or more of the following is true, DynamoDB rejects the entire batch
/// write operation:</para>
/// <ul>
/// <li> <para>One or more tables specified in the <i>BatchWriteItem</i> request does not exist.</para> </li>
/// <li> <para>Primary key attributes specified on an item in the request do not match those in the corresponding table's primary key
/// schema.</para> </li>
/// <li> <para>You try to perform multiple operations on the same item in the same <i>BatchWriteItem</i> request. For example, you cannot put
/// and delete the same item in the same <i>BatchWriteItem</i> request. </para> </li>
/// <li> <para>The total request size exceeds 1 MB.</para> </li>
/// <li> <para>Any individual item in a batch exceeds 64 KB.</para> </li>
///
/// </ul>
/// </summary>
///
/// <param name="batchWriteItemRequest">Container for the necessary parameters to execute the BatchWriteItem service method on
/// AmazonDynamoDBv2.</param>
///
/// <returns>The response from the BatchWriteItem service method, as returned by AmazonDynamoDBv2.</returns>
///
/// <exception cref="T:Amazon.DynamoDBv2.Model.ItemCollectionSizeLimitExceededException" />
/// <exception cref="T:Amazon.DynamoDBv2.Model.ResourceNotFoundException" />
/// <exception cref="T:Amazon.DynamoDBv2.Model.ProvisionedThroughputExceededException" />
/// <exception cref="T:Amazon.DynamoDBv2.Model.InternalServerErrorException" />
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
public Task<BatchWriteItemResponse> BatchWriteItemAsync(BatchWriteItemRequest batchWriteItemRequest, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new BatchWriteItemRequestMarshaller();
var unmarshaller = BatchWriteItemResponseUnmarshaller.GetInstance();
return Invoke<IRequest, BatchWriteItemRequest, BatchWriteItemResponse>(batchWriteItemRequest, marshaller, unmarshaller, signer, cancellationToken);
}
/// <summary>
/// Initiates the asynchronous execution of the BatchWriteItem operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the BatchWriteItem operation on AmazonDynamoDBClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndBatchWriteItem
/// operation.</returns>
public IAsyncResult BeginBatchWriteItem(BatchWriteItemRequest request, AsyncCallback callback, object state)
{
var marshaller = new BatchWriteItemRequestMarshaller();
var unmarshaller = BatchWriteItemResponseUnmarshaller.Instance;
return BeginInvoke<BatchWriteItemRequest>(request, marshaller, unmarshaller,
callback, state);
}
/// <summary>
/// The <i>BatchWriteItem</i> operation puts or deletes multiple items in one or more
/// tables. A single call to <i>BatchWriteItem</i> 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.
///
/// <note>
/// <para>
/// <i>BatchWriteItem</i> cannot update items. To update items, use the <i>UpdateItem</i>
/// API.
/// </para>
/// </note>
/// <para>
/// The individual <i>PutItem</i> and <i>DeleteItem</i> operations specified in <i>BatchWriteItem</i>
/// are atomic; however <i>BatchWriteItem</i> 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 <i>UnprocessedItems</i>
/// response parameter. You can investigate and optionally resend the requests. Typically,
/// you would call <i>BatchWriteItem</i> in a loop. Each iteration would check for unprocessed
/// items and submit a new <i>BatchWriteItem</i> request with those unprocessed items
/// until all items have been processed.
/// </para>
///
/// <para>
/// Note that if <i>none</i> of the items can be processed due to insufficient provisioned
/// throughput on all of the tables in the request, then <i>BatchWriteItem</i> will return
/// a <i>ProvisionedThroughputExceededException</i>.
/// </para>
/// <important>
/// <para>
/// If DynamoDB returns any unprocessed items, you should retry the batch operation on
/// those items. However, <i>we strongly recommend that you use an exponential backoff
/// algorithm</i>. 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.
/// </para>
///
/// <para>
/// For more information, see <a href="http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#BatchOperations">Batch
/// Operations and Error Handling</a> in the <i>Amazon DynamoDB Developer Guide</i>.
/// </para>
/// </important>
/// <para>
/// With <i>BatchWriteItem</i>, you can efficiently write or delete large amounts of data,
/// such as from Amazon Elastic MapReduce (EMR), or copy data from another database into
/// DynamoDB. In order to improve performance with these large-scale operations, <i>BatchWriteItem</i>
/// does not behave in the same way as individual <i>PutItem</i> and <i>DeleteItem</i>
/// calls would. For example, you cannot specify conditions on individual put and delete
/// requests, and <i>BatchWriteItem</i> does not return deleted items in the response.
/// </para>
///
/// <para>
/// 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, <i>BatchWriteItem</i> provides
/// an alternative where the API 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.
/// </para>
///
/// <para>
/// 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.
/// </para>
///
/// <para>
/// If one or more of the following is true, DynamoDB rejects the entire batch write operation:
/// </para>
/// <ul> <li>
/// <para>
/// One or more tables specified in the <i>BatchWriteItem</i> request does not exist.
/// </para>
/// </li> <li>
/// <para>
/// Primary key attributes specified on an item in the request do not match those in the
/// corresponding table's primary key schema.
/// </para>
/// </li> <li>
/// <para>
/// You try to perform multiple operations on the same item in the same <i>BatchWriteItem</i>
/// request. For example, you cannot put and delete the same item in the same <i>BatchWriteItem</i>
/// request.
/// </para>
/// </li> <li>
/// <para>
/// There are more than 25 requests in the batch.
/// </para>
/// </li> <li>
/// <para>
/// Any individual item in a batch exceeds 400 KB.
/// </para>
/// </li> <li>
/// <para>
/// The total request size exceeds 16 MB.
/// </para>
/// </li> </ul>
/// </summary>
/// <param name="requestItems">A map of one or more table names and, for each table, a list of operations to be performed (<i>DeleteRequest</i> or <i>PutRequest</i>). Each element in the map consists of the following: <ul> <li> <i>DeleteRequest</i> - Perform a <i>DeleteItem</i> operation on the specified item. The item to be deleted is identified by a <i>Key</i> subelement: <ul> <li> <i>Key</i> - 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 <i>all</i> of the key attributes. For example, with a hash type primary key, you only need to provide the hash attribute. For a hash-and-range type primary key, you must provide <i>both</i> the hash attribute and the range attribute. </li> </ul> </li> <li> <i>PutRequest</i> - Perform a <i>PutItem</i> operation on the specified item. The item to be put is identified by an <i>Item</i> subelement: <ul> <li> <i>Item</i> - 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 will be rejected with a <i>ValidationException</i> 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. </li> </ul> </li> </ul></param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
///
/// <returns>The response from the BatchWriteItem service method, as returned by DynamoDB.</returns>
/// <exception cref="Amazon.DynamoDBv2.Model.InternalServerErrorException">
/// An error occurred on the server side.
/// </exception>
/// <exception cref="Amazon.DynamoDBv2.Model.ItemCollectionSizeLimitExceededException">
/// An item collection is too large. This exception is only returned for tables that have
/// one or more local secondary indexes.
/// </exception>
/// <exception cref="Amazon.DynamoDBv2.Model.ProvisionedThroughputExceededException">
/// 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 <a href="http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#APIRetries">Error
/// Retries and Exponential Backoff</a> in the <i>Amazon DynamoDB Developer Guide</i>.
/// </exception>
/// <exception cref="Amazon.DynamoDBv2.Model.ResourceNotFoundException">
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be <code>ACTIVE</code>.
/// </exception>
public Task<BatchWriteItemResponse> BatchWriteItemAsync(Dictionary<string, List<WriteRequest>> requestItems, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var request = new BatchWriteItemRequest();
request.RequestItems = requestItems;
return BatchWriteItemAsync(request, cancellationToken);
}
internal BatchWriteItemResponse BatchWriteItem(BatchWriteItemRequest request)
{
var task = BatchWriteItemAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
throw e.InnerException;
}
}
/// <summary>
/// Initiates the asynchronous execution of the BatchWriteItem operation.
/// <seealso cref="Amazon.DynamoDBv2.IAmazonDynamoDB.BatchWriteItem"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the BatchWriteItem operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public async Task<BatchWriteItemResponse> BatchWriteItemAsync(BatchWriteItemRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new BatchWriteItemRequestMarshaller();
var unmarshaller = BatchWriteItemResponseUnmarshaller.GetInstance();
var response = await Invoke<IRequest, BatchWriteItemRequest, BatchWriteItemResponse>(request, marshaller, unmarshaller, signer, cancellationToken)
.ConfigureAwait(continueOnCapturedContext: false);
return response;
}
public void BatchSamples()
{
EnsureTables();
{
#region BatchGet Sample 1
// Define attributes to get and keys to retrieve
List<string> attributesToGet = new List<string> { "Author", "Title", "Year" };
List<Dictionary<string, AttributeValue>> sampleTableKeys = new List<Dictionary<string, AttributeValue>>
{
new Dictionary<string, AttributeValue>
{
{ "Author", new AttributeValue { S = "Mark Twain" } },
{ "Title", new AttributeValue { S = "The Adventures of Tom Sawyer" } }
},
new Dictionary<string, AttributeValue>
{
{ "Author", new AttributeValue { S = "Mark Twain" } },
{ "Title", new AttributeValue { S = "Adventures of Huckleberry Finn" } }
}
};
// Construct get-request for first table
KeysAndAttributes sampleTableItems = new KeysAndAttributes
{
AttributesToGet = attributesToGet,
Keys = sampleTableKeys
};
#endregion
#region BatchGet Sample 2
// Define keys to retrieve
List<Dictionary<string, AttributeValue>> authorsTableKeys = new List<Dictionary<string, AttributeValue>>
{
new Dictionary<string, AttributeValue>
{
{ "Author", new AttributeValue { S = "Mark Twain" } },
},
new Dictionary<string, AttributeValue>
{
{ "Author", new AttributeValue { S = "Booker Taliaferro Washington" } },
}
};
// Construct get-request for second table
// Skip setting AttributesToGet property to retrieve all attributes
KeysAndAttributes authorsTableItems = new KeysAndAttributes
{
Keys = authorsTableKeys,
};
#endregion
#region BatchGet Sample 3
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Construct table-keys mapping
Dictionary<string, KeysAndAttributes> requestItems = new Dictionary<string, KeysAndAttributes>();
requestItems["SampleTable"] = sampleTableItems;
requestItems["AuthorsTable"] = authorsTableItems;
// Construct request
BatchGetItemRequest request = new BatchGetItemRequest
{
RequestItems = requestItems
};
BatchGetItemResult result;
do
{
// Issue request and retrieve items
result = client.BatchGetItem(request);
// Iterate through responses
Dictionary<string, List<Dictionary<string, AttributeValue>>> responses = result.Responses;
foreach (string tableName in responses.Keys)
{
// Get items for each table
List<Dictionary<string, AttributeValue>> tableItems = responses[tableName];
// View items
foreach (Dictionary<string, AttributeValue> item in tableItems)
{
Console.WriteLine("Item:");
foreach (var keyValuePair in item)
{
Console.WriteLine("{0} : S={1}, N={2}, SS=[{3}], NS=[{4}]",
keyValuePair.Key,
keyValuePair.Value.S,
keyValuePair.Value.N,
string.Join(", ", keyValuePair.Value.SS ?? new List<string>()),
string.Join(", ", keyValuePair.Value.NS ?? new List<string>()));
}
}
}
// Some items may not have been retrieved!
// Set RequestItems to the result's UnprocessedKeys and reissue request
request.RequestItems = result.UnprocessedKeys;
} while (result.UnprocessedKeys.Count > 0);
#endregion
}
{
#region BatchWrite Sample 1
// Create items to put into first table
Dictionary<string, AttributeValue> item1 = new Dictionary<string, AttributeValue>();
item1["Author"] = new AttributeValue { S = "Mark Twain" };
item1["Title"] = new AttributeValue { S = "A Connecticut Yankee in King Arthur's Court" };
item1["Pages"] = new AttributeValue { N = "575" };
Dictionary<string, AttributeValue> item2 = new Dictionary<string, AttributeValue>();
item2["Author"] = new AttributeValue { S = "Booker Taliaferro Washington" };
item2["Title"] = new AttributeValue { S = "My Larger Education" };
item2["Pages"] = new AttributeValue { N = "313" };
item2["Year"] = new AttributeValue { N = "1911" };
// Create key for item to delete from first table
// Hash-key of the target item is string value "Mark Twain"
// Range-key of the target item is string value "Tom Sawyer, Detective"
Dictionary<string, AttributeValue> keyToDelete1 = new Dictionary<string, AttributeValue>
{
{ "Author", new AttributeValue { S = "Mark Twain" } },
{ "Title", new AttributeValue { S = "Tom Sawyer, Detective" } }
};
// Construct write-request for first table
List<WriteRequest> sampleTableItems = new List<WriteRequest>();
sampleTableItems.Add(new WriteRequest
{
PutRequest = new PutRequest { Item = item1 }
});
sampleTableItems.Add(new WriteRequest
{
PutRequest = new PutRequest { Item = item2 }
});
sampleTableItems.Add(new WriteRequest
{
DeleteRequest = new DeleteRequest { Key = keyToDelete1 }
});
#endregion
#region BatchWrite Sample 2
// Create key for item to delete from second table
// Hash-key of the target item is string value "Francis Scott Key Fitzgerald"
Dictionary<string, AttributeValue> keyToDelete2 = new Dictionary<string, AttributeValue>
{
{ "Author", new AttributeValue { S = "Francis Scott Key Fitzgerald" } },
};
// Construct write-request for first table
List<WriteRequest> authorsTableItems = new List<WriteRequest>();
authorsTableItems.Add(new WriteRequest
{
DeleteRequest = new DeleteRequest { Key = keyToDelete2 }
});
#endregion
#region BatchWrite Sample 3
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Construct table-keys mapping
Dictionary<string, List<WriteRequest>> requestItems = new Dictionary<string, List<WriteRequest>>();
requestItems["SampleTable"] = sampleTableItems;
requestItems["AuthorsTable"] = authorsTableItems;
BatchWriteItemRequest request = new BatchWriteItemRequest { RequestItems = requestItems };
BatchWriteItemResult result;
do
{
// Issue request and retrieve items
result = client.BatchWriteItem(request);
// Some items may not have been processed!
// Set RequestItems to the result's UnprocessedItems and reissue request
request.RequestItems = result.UnprocessedItems;
} while (result.UnprocessedItems.Count > 0);
#endregion
}
}
/// <summary>
/// Initiates the asynchronous execution of the BatchWriteItem operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the BatchWriteItem operation on AmazonDynamoDBClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
public void BatchWriteItemAsync(BatchWriteItemRequest request, AmazonServiceCallback<BatchWriteItemRequest, BatchWriteItemResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new BatchWriteItemRequestMarshaller();
var unmarshaller = BatchWriteItemResponseUnmarshaller.Instance;
Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult<BatchWriteItemRequest,BatchWriteItemResponse> responseObject
= new AmazonServiceResult<BatchWriteItemRequest,BatchWriteItemResponse>((BatchWriteItemRequest)req, (BatchWriteItemResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke<BatchWriteItemRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// The <i>BatchWriteItem</i> operation puts or deletes multiple items in one or more
/// tables. A single call to <i>BatchWriteItem</i> 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.
///
/// <note>
/// <para>
/// <i>BatchWriteItem</i> cannot update items. To update items, use the <i>UpdateItem</i>
/// API.
/// </para>
/// </note>
/// <para>
/// The individual <i>PutItem</i> and <i>DeleteItem</i> operations specified in <i>BatchWriteItem</i>
/// are atomic; however <i>BatchWriteItem</i> 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 <i>UnprocessedItems</i>
/// response parameter. You can investigate and optionally resend the requests. Typically,
/// you would call <i>BatchWriteItem</i> in a loop. Each iteration would check for unprocessed
/// items and submit a new <i>BatchWriteItem</i> request with those unprocessed items
/// until all items have been processed.
/// </para>
///
/// <para>
/// Note that if <i>none</i> of the items can be processed due to insufficient provisioned
/// throughput on all of the tables in the request, then <i>BatchWriteItem</i> will return
/// a <i>ProvisionedThroughputExceededException</i>.
/// </para>
/// <important>
/// <para>
/// If DynamoDB returns any unprocessed items, you should retry the batch operation on
/// those items. However, <i>we strongly recommend that you use an exponential backoff
/// algorithm</i>. 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.
/// </para>
///
/// <para>
/// For more information, go to <a href="http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#BatchOperations">Batch
/// Operations and Error Handling</a> in the <i>Amazon DynamoDB Developer Guide</i>.
/// </para>
/// </important>
/// <para>
/// With <i>BatchWriteItem</i>, you can efficiently write or delete large amounts of data,
/// such as from Amazon Elastic MapReduce (EMR), or copy data from another database into
/// DynamoDB. In order to improve performance with these large-scale operations, <i>BatchWriteItem</i>
/// does not behave in the same way as individual <i>PutItem</i> and <i>DeleteItem</i>
/// calls would. For example, you cannot specify conditions on individual put and delete
/// requests, and <i>BatchWriteItem</i> does not return deleted items in the response.
/// </para>
///
/// <para>
/// If you use a programming language that supports concurrency, such as Java, 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, such as
/// PHP, you must update provides an alternative where the API 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.
/// </para>
///
/// <para>
/// 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.
/// </para>
///
/// <para>
/// If one or more of the following is true, DynamoDB rejects the entire batch write operation:
/// </para>
/// <ul> <li>
/// <para>
/// One or more tables specified in the <i>BatchWriteItem</i> request does not exist.
/// </para>
/// </li> <li>
/// <para>
/// Primary key attributes specified on an item in the request do not match those in the
/// corresponding table's primary key schema.
/// </para>
/// </li> <li>
/// <para>
/// You try to perform multiple operations on the same item in the same <i>BatchWriteItem</i>
/// request. For example, you cannot put and delete the same item in the same <i>BatchWriteItem</i>
/// request.
/// </para>
/// </li> <li>
/// <para>
/// There are more than 25 requests in the batch.
/// </para>
/// </li> <li>
/// <para>
/// Any individual item in a batch exceeds 400 KB.
/// </para>
/// </li> <li>
/// <para>
/// The total request size exceeds 16 MB.
/// </para>
/// </li> </ul>
/// </summary>
/// <param name="requestItems">A map of one or more table names and, for each table, a list of operations to be performed (<i>DeleteRequest</i> or <i>PutRequest</i>). Each element in the map consists of the following: <ul> <li> <i>DeleteRequest</i> - Perform a <i>DeleteItem</i> operation on the specified item. The item to be deleted is identified by a <i>Key</i> subelement: <ul> <li> <i>Key</i> - 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 <i>all</i> of the key attributes. For example, with a hash type primary key, you only need to provide the hash attribute. For a hash-and-range type primary key, you must provide <i>both</i> the hash attribute and the range attribute. </li> </ul> </li> <li> <i>PutRequest</i> - Perform a <i>PutItem</i> operation on the specified item. The item to be put is identified by an <i>Item</i> subelement: <ul> <li> <i>Item</i> - 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 will be rejected with a <i>ValidationException</i> 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. </li> </ul> </li> </ul></param>
///
/// <returns>The response from the BatchWriteItem service method, as returned by DynamoDB.</returns>
/// <exception cref="Amazon.DynamoDBv2.Model.InternalServerErrorException">
/// An error occurred on the server side.
/// </exception>
/// <exception cref="Amazon.DynamoDBv2.Model.ItemCollectionSizeLimitExceededException">
/// An item collection is too large. This exception is only returned for tables that have
/// one or more local secondary indexes.
/// </exception>
/// <exception cref="Amazon.DynamoDBv2.Model.ProvisionedThroughputExceededException">
/// The request rate is too high, or the request is too large, for the available throughput
/// to accommodate. The AWS SDKs automatically retry requests that receive this exception;
/// therefore, your request will eventually succeed, unless the request is too large or
/// your retry queue is too large to finish. Reduce the frequency of requests by using
/// the strategies listed in <a href="http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#APIRetries">Error
/// Retries and Exponential Backoff</a> in the <i>Amazon DynamoDB Developer Guide</i>.
/// </exception>
/// <exception cref="Amazon.DynamoDBv2.Model.ResourceNotFoundException">
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be <code>ACTIVE</code>.
/// </exception>
public void BatchWriteItemAsync(Dictionary<string, List<WriteRequest>> requestItems, AmazonServiceCallback<BatchWriteItemRequest, BatchWriteItemResponse> callback, AsyncOptions options = null)
{
var request = new BatchWriteItemRequest();
request.RequestItems = requestItems;
BatchWriteItemAsync(request, callback, options);
}
