public void BatchWriteItemMarshallTest()
{
var request = InstantiateClassGenerator.Execute <BatchWriteItemRequest>();
var marshaller = new BatchWriteItemRequestMarshaller();
var internalRequest = marshaller.Marshall(request);
var jsonRequest = UTF8Encoding.UTF8.GetString(internalRequest.Content);
Comparer.CompareObjectToJson <BatchWriteItemRequest>(request, jsonRequest);
var webResponse = new WebResponseData
{
Headers =
{
{ "x-amzn-RequestId", Guid.NewGuid().ToString() },
{ "x-amz-crc32", "0" }
}
};
var jsonResponse = new JsonSampleGenerator(service_model, service_model.FindOperation("BatchWriteItem").ResponseStructure).Execute();
webResponse.Headers.Add("Content-Length", UTF8Encoding.UTF8.GetBytes(jsonResponse).Length.ToString());
UnmarshallerContext context = new JsonUnmarshallerContext(Utils.CreateStreamFromString(jsonResponse), false, webResponse);
var response = BatchWriteItemResponseUnmarshaller.Instance.Unmarshall(context)
as BatchWriteItemResponse;
InstantiateClassGenerator.ValidateObjectFullyInstantiated(response);
}
internal BatchWriteItemResponse BatchWriteItem(BatchWriteItemRequest request)
{
var marshaller = new BatchWriteItemRequestMarshaller();
var unmarshaller = BatchWriteItemResponseUnmarshaller.Instance;
return(Invoke <BatchWriteItemRequest, BatchWriteItemResponse>(request, marshaller, unmarshaller));
}
/// <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
/// 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, 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.</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.IAmazonDynamoDB"/>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the BatchWriteItem operation.</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>void</returns>
public void BatchWriteItemAsync(BatchWriteItemRequest request, AmazonServiceCallback callback, object state)
{
if (!AmazonInitializer.IsInitialized)
{
throw new Exception("AWSPrefab is not added to the scene");
}
ThreadPool.QueueUserWorkItem(new WaitCallback(delegate
{
var marshaller = new BatchWriteItemRequestMarshaller();
var unmarshaller = BatchWriteItemResponseUnmarshaller.Instance;
Invoke(request, callback, state, marshaller, unmarshaller, signer);
}));
return;
}
public void BatchWriteItemMarshallTest()
{
var request = InstantiateClassGenerator.Execute<BatchWriteItemRequest>();
var marshaller = new BatchWriteItemRequestMarshaller();
var internalRequest = marshaller.Marshall(request);
var jsonRequest = UTF8Encoding.UTF8.GetString(internalRequest.Content);
Comparer.CompareObjectToJson<BatchWriteItemRequest>(request,jsonRequest);
var webResponse = new WebResponseData
{
Headers = {
{"x-amzn-RequestId", Guid.NewGuid().ToString()},
{"x-amz-crc32","0"}
}
};
var jsonResponse = new JsonSampleGenerator(service_model, service_model.FindOperation("BatchWriteItem").ResponseStructure).Execute();
webResponse.Headers.Add("Content-Length", UTF8Encoding.UTF8.GetBytes(jsonResponse).Length.ToString());
UnmarshallerContext context = new JsonUnmarshallerContext(Utils.CreateStreamFromString(jsonResponse), false, webResponse);
var response = BatchWriteItemResponseUnmarshaller.Instance.Unmarshall(context)
as BatchWriteItemResponse;
InstantiateClassGenerator.ValidateObjectFullyInstantiated(response);
}
/// <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);
}
internal BatchWriteItemResponse BatchWriteItem(BatchWriteItemRequest request)
{
var marshaller = new BatchWriteItemRequestMarshaller();
var unmarshaller = BatchWriteItemResponseUnmarshaller.Instance;
return Invoke<BatchWriteItemRequest,BatchWriteItemResponse>(request, marshaller, unmarshaller);
}
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>
/// <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>
/// 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;
}
/// <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);
}
