// Delete TestID Table
public static void DeleteData1(int Id)
{
var Req = new Amazon.DynamoDBv2.Model.DeleteItemRequest
{
TableName = "TestID",
Key = new Dictionary<string, Amazon.DynamoDBv2.Model.AttributeValue>() { { "Id", new Amazon.DynamoDBv2.Model.AttributeValue { N = Id.ToString() } } }
};
var Rsp = client.DeleteItem(Req);
}
public static void DeleteData(string UID, string tableName)
{
var Req = new Amazon.DynamoDBv2.Model.DeleteItemRequest
{
TableName = tableName,
Key = new Dictionary<string, Amazon.DynamoDBv2.Model.AttributeValue>() {{"UID",new Amazon.DynamoDBv2.Model.AttributeValue{S=UID}} }
};
var Rsp = client.DeleteItem(Req);
}
public async Task DeleteUserByUserName(string username)
{
var Req = new Amazon.DynamoDBv2.Model.DeleteItemRequest
{
TableName = this.tableName,
Key = new Dictionary <string, Amazon.DynamoDBv2.Model.AttributeValue>()
{
{ "username", new Amazon.DynamoDBv2.Model.AttributeValue {
S = username.ToString()
} }
}
};
var response = await DynamoDbClientService.getDynamoDBClient(environment).DeleteItemAsync(Req);
var attributeList = response.Attributes;
}
public int DeleteItem(string primaryKeyName, string primaryKeyValue, string table)
{
int response = (int)DBEnum.DBResponseCodes.DEFAULT_VALUE;
DeleteItemRequest request = new DeleteItemRequest(); // generate new deleterequest
request.TableName = table; // set to table name
request.Key = new Dictionary<string, AttributeValue>() { { primaryKeyName , new AttributeValue { S = primaryKeyValue } } };
try
{
this.client.DeleteItem(request);
response = (int)DBEnum.DBResponseCodes.SUCCESS;
}
catch
{
response = (int)DBEnum.DBResponseCodes.DYNAMODB_EXCEPTION;
}
return response;
}
public async Task DeleteCitybyCompositeKey(string state, string city)
{
var deleteItemRequest = new Amazon.DynamoDBv2.Model.DeleteItemRequest
{
TableName = this.tableName,
Key = new Dictionary <string, Amazon.DynamoDBv2.Model.AttributeValue>()
{
{ "state", new Amazon.DynamoDBv2.Model.AttributeValue {
S = state.ToString()
} },
{ "city", new Amazon.DynamoDBv2.Model.AttributeValue {
S = city.ToString()
} }
}
};
var response = await DynamoDbClientService.getDynamoDBClient(environment).DeleteItemAsync(deleteItemRequest);
var attributeList = response.Attributes;
}
internal DeleteItemResponse DeleteItem(DeleteItemRequest request)
{
var marshaller = new DeleteItemRequestMarshaller();
var unmarshaller = DeleteItemResponseUnmarshaller.Instance;
return Invoke<DeleteItemRequest,DeleteItemResponse>(request, marshaller, unmarshaller);
}
/// <summary>
/// Initiates the asynchronous execution of the DeleteItem operation.
/// <seealso cref="Amazon.DynamoDBv2.AmazonDynamoDB.DeleteItem"/>
/// </summary>
///
/// <param name="deleteItemRequest">Container for the necessary parameters to execute the DeleteItem 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 EndDeleteItem
/// operation.</returns>
public IAsyncResult BeginDeleteItem(DeleteItemRequest deleteItemRequest, AsyncCallback callback, object state)
{
return invokeDeleteItem(deleteItemRequest, callback, state, false);
}
/// <summary>
/// <para>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.</para> <para>In addition to deleting an item, you can also return the item's attribute values in the
/// same operation, using the <i>ReturnValues</i> parameter.</para> <para>Unless you specify conditions, the <i>DeleteItem</i> is an idempotent
/// operation; running it multiple times on the same item or attribute does <i>not</i> result in an error response.</para> <para>Conditional
/// deletes are useful for only deleting items if specific conditions are met. If those conditions are met, Amazon DynamoDB performs the delete.
/// Otherwise, the item is not deleted. </para>
/// </summary>
///
/// <param name="deleteItemRequest">Container for the necessary parameters to execute the DeleteItem service method on AmazonDynamoDBv2.</param>
///
/// <returns>The response from the DeleteItem service method, as returned by AmazonDynamoDBv2.</returns>
///
/// <exception cref="ItemCollectionSizeLimitExceededException"/>
/// <exception cref="ResourceNotFoundException"/>
/// <exception cref="ConditionalCheckFailedException"/>
/// <exception cref="ProvisionedThroughputExceededException"/>
/// <exception cref="InternalServerErrorException"/>
public DeleteItemResponse DeleteItem(DeleteItemRequest deleteItemRequest)
{
IAsyncResult asyncResult = invokeDeleteItem(deleteItemRequest, null, null, true);
return EndDeleteItem(asyncResult);
}
/// <summary>
/// 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.
///
///
/// <para>
/// In addition to deleting an item, you can also return the item's attribute values in
/// the same operation, using the <i>ReturnValues</i> parameter.
/// </para>
///
/// <para>
/// Unless you specify conditions, the <i>DeleteItem</i> is an idempotent operation; running
/// it multiple times on the same item or attribute does <i>not</i> result in an error
/// response.
/// </para>
///
/// <para>
/// 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.
/// </para>
/// </summary>
/// <param name="tableName">The name of the table from which to delete the item.</param>
/// <param name="key">A map of attribute names to <i>AttributeValue</i> 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 hash type primary key, you only need to provide the hash attribute. For a hash-and-range type primary key, you must provide both the hash attribute and the range attribute.</param>
/// <param name="returnValues">Use <i>ReturnValues</i> if you want to get the item attributes as they appeared before they were deleted. For <i>DeleteItem</i>, the valid values are: <ul> <li> <code>NONE</code> - If <i>ReturnValues</i> is not specified, or if its value is <code>NONE</code>, then nothing is returned. (This setting is the default for <i>ReturnValues</i>.) </li> <li> <code>ALL_OLD</code> - The content of the old item is returned. </li> </ul></param>
///
/// <returns>The response from the DeleteItem service method, as returned by DynamoDB.</returns>
/// <exception cref="Amazon.DynamoDBv2.Model.ConditionalCheckFailedException">
/// A condition specified in the operation could not be evaluated.
/// </exception>
/// <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 DeleteItemResponse DeleteItem(string tableName, Dictionary<string, AttributeValue> key, ReturnValue returnValues)
{
var request = new DeleteItemRequest();
request.TableName = tableName;
request.Key = key;
request.ReturnValues = returnValues;
return DeleteItem(request);
}
IAsyncResult invokeDeleteItem(DeleteItemRequest deleteItemRequest, AsyncCallback callback, object state, bool synchronized)
{
IRequest irequest = new DeleteItemRequestMarshaller().Marshall(deleteItemRequest);
var unmarshaller = DeleteItemResponseUnmarshaller.GetInstance();
AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller);
Invoke(result);
return result;
}
internal Document DeleteHelper(Key key, DeleteItemOperationConfig config, bool isAsync)
{
var currentConfig = config ?? new DeleteItemOperationConfig();
var req = new DeleteItemRequest
{
TableName = TableName,
Key = key
};
req.BeforeRequestEvent += isAsync ?
new RequestEventHandler(UserAgentRequestEventHandlerAsync) :
new RequestEventHandler(UserAgentRequestEventHandlerSync);
if (currentConfig.ReturnValues == ReturnValues.AllOldAttributes)
req.ReturnValues = EnumMapper.Convert(currentConfig.ReturnValues);
if (currentConfig.Expected != null && currentConfig.ExpectedState != null)
throw new InvalidOperationException("Expected and ExpectedState cannot be set at the same time");
if (currentConfig.Expected != null)
req.Expected = currentConfig.Expected.ToExpectedAttributeMap();
if (currentConfig.ExpectedState != null &&
currentConfig.ExpectedState.ExpectedValues != null &&
currentConfig.ExpectedState.ExpectedValues.Count > 0)
{
req.Expected = currentConfig.ExpectedState.ToExpectedAttributeMap();
if (req.Expected.Count > 1)
req.ConditionalOperator = EnumMapper.Convert(currentConfig.ExpectedState.ConditionalOperator);
}
var attributes = DDBClient.DeleteItem(req).Attributes;
Document ret = null;
if (currentConfig.ReturnValues == ReturnValues.AllOldAttributes)
{
ret = Document.FromAttributeMap(attributes);
}
return ret;
}
public void CRUDSamples()
{
EnsureTables();
PutSample();
{
#region GetItem Sample
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Define item key
// Hash-key of the target item is string value "Mark Twain"
// Range-key of the target item is string value "The Adventures of Tom Sawyer"
Dictionary<string, AttributeValue> key = new Dictionary<string, AttributeValue>
{
{ "Author", new AttributeValue { S = "Mark Twain" } },
{ "Title", new AttributeValue { S = "The Adventures of Tom Sawyer" } }
};
// Create GetItem request
GetItemRequest request = new GetItemRequest
{
TableName = "SampleTable",
Key = key,
};
// Issue request
var result = client.GetItem(request);
// View response
Console.WriteLine("Item:");
Dictionary<string, AttributeValue> item = result.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>()));
}
#endregion
}
{
#region UpdateItem Sample
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Define item key
// Hash-key of the target item is string value "Mark Twain"
// Range-key of the target item is string value "The Adventures of Tom Sawyer"
Dictionary<string, AttributeValue> key = new Dictionary<string, AttributeValue>
{
{ "Author", new AttributeValue { S = "Mark Twain" } },
{ "Title", new AttributeValue { S = "The Adventures of Tom Sawyer" } }
};
// Define attribute updates
Dictionary<string, AttributeValueUpdate> updates = new Dictionary<string, AttributeValueUpdate>();
// Update item's Setting attribute
updates["Setting"] = new AttributeValueUpdate()
{
Action = AttributeAction.PUT,
Value = new AttributeValue { S = "St. Petersburg, Missouri" }
};
// Remove item's Bibliography attribute
updates["Bibliography"] = new AttributeValueUpdate()
{
Action = AttributeAction.DELETE
};
// Add a new string to the item's Genres SS attribute
updates["Genres"] = new AttributeValueUpdate()
{
Action = AttributeAction.ADD,
Value = new AttributeValue { SS = new List<string> { "Bildungsroman" } }
};
// Create UpdateItem request
UpdateItemRequest request = new UpdateItemRequest
{
TableName = "SampleTable",
Key = key,
AttributeUpdates = updates
};
// Issue request
client.UpdateItem(request);
#endregion
}
{
#region DeleteItem Sample
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Define item key
// Hash-key of the target item is string value "Mark Twain"
// Range-key of the target item is string value "The Adventures of Tom Sawyer"
Dictionary<string, AttributeValue> key = new Dictionary<string, AttributeValue>
{
{ "Author", new AttributeValue { S = "Mark Twain" } },
{ "Title", new AttributeValue { S = "The Adventures of Tom Sawyer" } }
};
// Create DeleteItem request
DeleteItemRequest request = new DeleteItemRequest
{
TableName = "SampleTable",
Key = key
};
// Issue request
client.DeleteItem(request);
#endregion
}
}
/// <summary>
/// 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.
///
///
/// <para>
/// In addition to deleting an item, you can also return the item's attribute values in
/// the same operation, using the <i>ReturnValues</i> parameter.
/// </para>
///
/// <para>
/// Unless you specify conditions, the <i>DeleteItem</i> is an idempotent operation; running
/// it multiple times on the same item or attribute does <i>not</i> result in an error
/// response.
/// </para>
///
/// <para>
/// 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.
/// </para>
/// </summary>
/// <param name="tableName">The name of the table from which to delete the item.</param>
/// <param name="key">A map of attribute names to <i>AttributeValue</i> 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 hash type primary key, you only need to provide the hash attribute. For a hash-and-range type primary key, you must provide both the hash attribute and the range attribute.</param>
/// <param name="returnValues">Use <i>ReturnValues</i> if you want to get the item attributes as they appeared before they were deleted. For <i>DeleteItem</i>, the valid values are: <ul> <li> <code>NONE</code> - If <i>ReturnValues</i> is not specified, or if its value is <code>NONE</code>, then nothing is returned. (This setting is the default for <i>ReturnValues</i>.) </li> <li> <code>ALL_OLD</code> - The content of the old item is returned. </li> </ul></param>
///
/// <returns>The response from the DeleteItem service method, as returned by DynamoDB.</returns>
/// <exception cref="Amazon.DynamoDBv2.Model.ConditionalCheckFailedException">
/// A condition specified in the operation could not be evaluated.
/// </exception>
/// <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 DeleteItemAsync(string tableName, Dictionary<string, AttributeValue> key, ReturnValue returnValues, AmazonServiceCallback<DeleteItemRequest, DeleteItemResponse> callback, AsyncOptions options = null)
{
var request = new DeleteItemRequest();
request.TableName = tableName;
request.Key = key;
request.ReturnValues = returnValues;
DeleteItemAsync(request, callback, options);
}
/// <summary>
/// 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.
///
///
/// <para>
/// In addition to deleting an item, you can also return the item's attribute values in
/// the same operation, using the <i>ReturnValues</i> parameter.
/// </para>
///
/// <para>
/// Unless you specify conditions, the <i>DeleteItem</i> is an idempotent operation; running
/// it multiple times on the same item or attribute does <i>not</i> result in an error
/// response.
/// </para>
///
/// <para>
/// 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.
/// </para>
/// </summary>
/// <param name="tableName">The name of the table from which to delete the item.</param>
/// <param name="key">A map of attribute names to <i>AttributeValue</i> 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 hash type primary key, you only need to provide the hash attribute. For a hash-and-range type primary key, you must provide both the hash attribute and the range attribute.</param>
/// <param name="returnValues">Use <i>ReturnValues</i> if you want to get the item attributes as they appeared before they were deleted. For <i>DeleteItem</i>, the valid values are: <ul> <li> <code>NONE</code> - If <i>ReturnValues</i> is not specified, or if its value is <code>NONE</code>, then nothing is returned. (This setting is the default for <i>ReturnValues</i>.) </li> <li> <code>ALL_OLD</code> - The content of the old item is returned. </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 DeleteItem service method, as returned by DynamoDB.</returns>
/// <exception cref="Amazon.DynamoDBv2.Model.ConditionalCheckFailedException">
/// A condition specified in the operation could not be evaluated.
/// </exception>
/// <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<DeleteItemResponse> DeleteItemAsync(string tableName, Dictionary<string, AttributeValue> key, ReturnValue returnValues, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var request = new DeleteItemRequest();
request.TableName = tableName;
request.Key = key;
request.ReturnValues = returnValues;
return DeleteItemAsync(request, cancellationToken);
}
internal DeleteItemResponse DeleteItem(DeleteItemRequest request)
{
var task = DeleteItemAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
throw e.InnerException;
}
}
internal void ApplyExpression(DeleteItemRequest request, DynamoDBEntryConversion conversion)
{
request.ConditionExpression = this.ExpressionStatement;
request.ExpressionAttributeNames = new Dictionary<string, string>(this.ExpressionAttributeNames);
request.ExpressionAttributeValues = ConvertToAttributeValues(this.ExpressionAttributeValues, conversion);
}
internal Document DeleteHelper(Key key, DeleteItemOperationConfig config, bool isAsync)
{
var currentConfig = config ?? new DeleteItemOperationConfig();
var req = new DeleteItemRequest
{
TableName = TableName,
Key = key
};
req.BeforeRequestEvent += isAsync ?
new RequestEventHandler(UserAgentRequestEventHandlerAsync) :
new RequestEventHandler(UserAgentRequestEventHandlerSync);
if (currentConfig.ReturnValues == ReturnValues.AllOldAttributes)
{
req.ReturnValues = EnumToStringMapper.Convert(currentConfig.ReturnValues);
}
if (currentConfig.Expected != null)
{
req.Expected = currentConfig.Expected.ToExpectedAttributeMap();
}
var attributes = DDBClient.DeleteItem(req).Attributes;
Document ret = null;
if (currentConfig.ReturnValues == ReturnValues.AllOldAttributes)
{
ret = Document.FromAttributeMap(attributes);
}
return ret;
}
public void Delete_item_with_AWSSDK()
{
db.PutItem(new Todo { Id = 1, Content = "TODO 1", Order = 1 });
var request = new DeleteItemRequest
{
TableName = "Todo",
Key = new Dictionary<string, AttributeValue> {
{ "Id", new AttributeValue { N = "1"} }
},
};
awsDb.DeleteItem(request);
Assert.That(db.GetItem<Todo>(1), Is.Null);
}
/// <summary>
/// Initiates the asynchronous execution of the DeleteItem operation.
/// <seealso cref="Amazon.DynamoDBv2.IAmazonDynamoDB.DeleteItem"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DeleteItem 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<DeleteItemResponse> DeleteItemAsync(DeleteItemRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new DeleteItemRequestMarshaller();
var unmarshaller = DeleteItemResponseUnmarshaller.GetInstance();
var response = await Invoke<IRequest, DeleteItemRequest, DeleteItemResponse>(request, marshaller, unmarshaller, signer, cancellationToken)
.ConfigureAwait(continueOnCapturedContext: false);
return response;
}
/// <summary>
/// Initiates the asynchronous execution of the DeleteItem operation.
/// <seealso cref="Amazon.DynamoDBv2.IAmazonDynamoDB"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DeleteItem 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<DeleteItemResponse> DeleteItemAsync(DeleteItemRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new DeleteItemRequestMarshaller();
var unmarshaller = DeleteItemResponseUnmarshaller.Instance;
return InvokeAsync<DeleteItemRequest,DeleteItemResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
internal DeleteItemResponse DeleteItem(DeleteItemRequest request)
{
var task = DeleteItemAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return null;
}
}
internal Document DeleteHelper(Key key, DeleteItemOperationConfig config, bool isAsync)
{
var currentConfig = config ?? new DeleteItemOperationConfig();
var req = new DeleteItemRequest
{
TableName = TableName,
Key = key
};
((Amazon.Runtime.Internal.IAmazonWebServiceRequest)req).AddBeforeRequestHandler(isAsync ?
new RequestEventHandler(UserAgentRequestEventHandlerAsync) :
new RequestEventHandler(UserAgentRequestEventHandlerSync)
);
if (currentConfig.ReturnValues == ReturnValues.AllOldAttributes)
req.ReturnValues = EnumMapper.Convert(currentConfig.ReturnValues);
ValidateConditional(currentConfig);
if (currentConfig.Expected != null)
{
req.Expected = currentConfig.Expected.ToExpectedAttributeMap(Conversion);
}
else if (currentConfig.ExpectedState != null &&
currentConfig.ExpectedState.ExpectedValues != null &&
currentConfig.ExpectedState.ExpectedValues.Count > 0)
{
req.Expected = currentConfig.ExpectedState.ToExpectedAttributeMap(Conversion);
if (req.Expected.Count > 1)
req.ConditionalOperator = EnumMapper.Convert(currentConfig.ExpectedState.ConditionalOperator);
}
else if (currentConfig.ConditionalExpression != null && currentConfig.ConditionalExpression.IsSet)
{
currentConfig.ConditionalExpression.ApplyExpression(req, this.Conversion);
}
var attributes = DDBClient.DeleteItem(req).Attributes;
Document ret = null;
if (currentConfig.ReturnValues == ReturnValues.AllOldAttributes)
{
ret = Document.FromAttributeMap(attributes);
}
return ret;
}
/// <summary>
/// <para>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.</para> <para>In addition to deleting an item, you can also return the item's attribute values in the
/// same operation, using the <i>ReturnValues</i> parameter.</para> <para>Unless you specify conditions, the <i>DeleteItem</i> is an idempotent
/// operation; running it multiple times on the same item or attribute does <i>not</i> result in an error response.</para> <para>Conditional
/// deletes are useful for only deleting items if specific conditions are met. If those conditions are met, DynamoDB performs the delete.
/// Otherwise, the item is not deleted. </para>
/// </summary>
///
/// <param name="deleteItemRequest">Container for the necessary parameters to execute the DeleteItem service method on AmazonDynamoDBv2.</param>
///
/// <returns>The response from the DeleteItem 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.ConditionalCheckFailedException" />
/// <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<DeleteItemResponse> DeleteItemAsync(DeleteItemRequest deleteItemRequest, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new DeleteItemRequestMarshaller();
var unmarshaller = DeleteItemResponseUnmarshaller.GetInstance();
return Invoke<IRequest, DeleteItemRequest, DeleteItemResponse>(deleteItemRequest, marshaller, unmarshaller, signer, cancellationToken);
}
/// <summary>
/// Initiates the asynchronous execution of the DeleteItem operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DeleteItem 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 EndDeleteItem
/// operation.</returns>
public IAsyncResult BeginDeleteItem(DeleteItemRequest request, AsyncCallback callback, object state)
{
var marshaller = new DeleteItemRequestMarshaller();
var unmarshaller = DeleteItemResponseUnmarshaller.Instance;
return BeginInvoke<DeleteItemRequest>(request, marshaller, unmarshaller,
callback, state);
}
/// <summary>
/// Initiates the asynchronous execution of the DeleteItem operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DeleteItem 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 DeleteItemAsync(DeleteItemRequest request, AmazonServiceCallback<DeleteItemRequest, DeleteItemResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new DeleteItemRequestMarshaller();
var unmarshaller = DeleteItemResponseUnmarshaller.Instance;
Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult<DeleteItemRequest,DeleteItemResponse> responseObject
= new AmazonServiceResult<DeleteItemRequest,DeleteItemResponse>((DeleteItemRequest)req, (DeleteItemResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke<DeleteItemRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
