| Method | Description | |
|---|---|---|
| AmazonDynamoDBClient ( ) : System |
Constructs AmazonDynamoDBClient with the credentials loaded from the application's default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance. Example App.config with credentials set.
|
|
|
AmazonDynamoDBClient ( |
Constructs AmazonDynamoDBClient with AWS Credentials
|
|
|
AmazonDynamoDBClient ( |
Constructs AmazonDynamoDBClient with AWS Credentials and an AmazonDynamoDBClient Configuration object.
|
|
|
AmazonDynamoDBClient ( |
Constructs AmazonDynamoDBClient with AWS Credentials
|
|
|
AmazonDynamoDBClient ( |
Constructs AmazonDynamoDBClient with the credentials loaded from the application's default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance. Example App.config with credentials set.
|
|
| AmazonDynamoDBClient ( RegionEndpoint region ) : System |
Constructs AmazonDynamoDBClient with the credentials loaded from the application's default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance. Example App.config with credentials set.
|
|
| AmazonDynamoDBClient ( string awsAccessKeyId, string awsSecretAccessKey ) : System |
Constructs AmazonDynamoDBClient with AWS Access Key ID and AWS Secret Key
|
|
|
AmazonDynamoDBClient ( string awsAccessKeyId, string awsSecretAccessKey, |
Constructs AmazonDynamoDBClient with AWS Access Key ID, AWS Secret Key and an AmazonDynamoDBClient Configuration object.
|
|
| AmazonDynamoDBClient ( string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region ) : System |
Constructs AmazonDynamoDBClient with AWS Access Key ID and AWS Secret Key
|
|
| AmazonDynamoDBClient ( string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken ) : System |
Constructs AmazonDynamoDBClient with AWS Access Key ID and AWS Secret Key
|
|
|
AmazonDynamoDBClient ( string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, |
Constructs AmazonDynamoDBClient with AWS Access Key ID, AWS Secret Key and an AmazonDynamoDBClient Configuration object.
|
|
| AmazonDynamoDBClient ( string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region ) : System |
Constructs AmazonDynamoDBClient with AWS Access Key ID and AWS Secret Key
|
|
|
BatchGetItem ( |
The BatchGetItem operation returns the attributes of one or more items from one or more tables. You identify requested items by primary key. A single operation can retrieve up to 16 MB of data, which can contain as many as 100 items. BatchGetItem will return a partial result if the response size limit is exceeded, the table's provisioned throughput is exceeded, or an internal processing failure occurs. If a partial result is returned, the operation returns a value for UnprocessedKeys. You can use this value to retry the operation starting with the next item to get. If you request more than 100 items BatchGetItem will return a ValidationException with the message "Too many items requested for the BatchGetItem call". For example, if you ask to retrieve 100 items, but each individual item is 300 KB in size, the system returns 52 items (so as not to exceed the 16 MB limit). It also returns an appropriate UnprocessedKeys value so you can get the next page of results. If desired, your application can include its own logic to assemble the pages of results into one data set. If none of the items can be processed due to insufficient provisioned throughput on all of the tables in the request, then BatchGetItem will return a ProvisionedThroughputExceededException. If at least one of the items is successfully processed, then BatchGetItem completes successfully, while returning the keys of the unread items in UnprocessedKeys. If DynamoDB returns any unprocessed items, you should retry the batch operation on those items. However, we strongly recommend that you use an exponential backoff algorithm. If you retry the batch operation immediately, the underlying read or write requests can still fail due to throttling on the individual tables. If you delay the batch operation using exponential backoff, the individual requests in the batch are much more likely to succeed. For more information, see Batch Operations and Error Handling in the Amazon DynamoDB Developer Guide. By default, BatchGetItem performs eventually consistent reads on every table in the request. If you want strongly consistent reads instead, you can set ConsistentRead to In order to minimize response latency, BatchGetItem retrieves items in parallel. When designing your application, keep in mind that DynamoDB does not return items in any particular order. To help parse the response by item, include the primary key values for the items in your request in the AttributesToGet parameter. If a requested item does not exist, it is not returned in the result. Requests for nonexistent items consume the minimum read capacity units according to the type of read. For more information, see Capacity Units Calculations in the Amazon DynamoDB Developer Guide.
|
|
|
BatchGetItem ( KeysAndAttributes>.Dictionary |
The BatchGetItem operation returns the attributes of one or more items from one or more tables. You identify requested items by primary key. A single operation can retrieve up to 16 MB of data, which can contain as many as 100 items. BatchGetItem will return a partial result if the response size limit is exceeded, the table's provisioned throughput is exceeded, or an internal processing failure occurs. If a partial result is returned, the operation returns a value for UnprocessedKeys. You can use this value to retry the operation starting with the next item to get. If you request more than 100 items BatchGetItem will return a ValidationException with the message "Too many items requested for the BatchGetItem call". For example, if you ask to retrieve 100 items, but each individual item is 300 KB in size, the system returns 52 items (so as not to exceed the 16 MB limit). It also returns an appropriate UnprocessedKeys value so you can get the next page of results. If desired, your application can include its own logic to assemble the pages of results into one data set. If none of the items can be processed due to insufficient provisioned throughput on all of the tables in the request, then BatchGetItem will return a ProvisionedThroughputExceededException. If at least one of the items is successfully processed, then BatchGetItem completes successfully, while returning the keys of the unread items in UnprocessedKeys. If DynamoDB returns any unprocessed items, you should retry the batch operation on those items. However, we strongly recommend that you use an exponential backoff algorithm. If you retry the batch operation immediately, the underlying read or write requests can still fail due to throttling on the individual tables. If you delay the batch operation using exponential backoff, the individual requests in the batch are much more likely to succeed. For more information, see Batch Operations and Error Handling in the Amazon DynamoDB Developer Guide. By default, BatchGetItem performs eventually consistent reads on every table in the request. If you want strongly consistent reads instead, you can set ConsistentRead to In order to minimize response latency, BatchGetItem retrieves items in parallel. When designing your application, keep in mind that DynamoDB does not return items in any particular order. To help parse the response by item, include the primary key values for the items in your request in the AttributesToGet parameter. If a requested item does not exist, it is not returned in the result. Requests for nonexistent items consume the minimum read capacity units according to the type of read. For more information, see Capacity Units Calculations in the Amazon DynamoDB Developer Guide.
|
|
|
BatchGetItem ( KeysAndAttributes>.Dictionary |
The BatchGetItem operation returns the attributes of one or more items from one or more tables. You identify requested items by primary key. A single operation can retrieve up to 16 MB of data, which can contain as many as 100 items. BatchGetItem will return a partial result if the response size limit is exceeded, the table's provisioned throughput is exceeded, or an internal processing failure occurs. If a partial result is returned, the operation returns a value for UnprocessedKeys. You can use this value to retry the operation starting with the next item to get. If you request more than 100 items BatchGetItem will return a ValidationException with the message "Too many items requested for the BatchGetItem call". For example, if you ask to retrieve 100 items, but each individual item is 300 KB in size, the system returns 52 items (so as not to exceed the 16 MB limit). It also returns an appropriate UnprocessedKeys value so you can get the next page of results. If desired, your application can include its own logic to assemble the pages of results into one data set. If none of the items can be processed due to insufficient provisioned throughput on all of the tables in the request, then BatchGetItem will return a ProvisionedThroughputExceededException. If at least one of the items is successfully processed, then BatchGetItem completes successfully, while returning the keys of the unread items in UnprocessedKeys. If DynamoDB returns any unprocessed items, you should retry the batch operation on those items. However, we strongly recommend that you use an exponential backoff algorithm. If you retry the batch operation immediately, the underlying read or write requests can still fail due to throttling on the individual tables. If you delay the batch operation using exponential backoff, the individual requests in the batch are much more likely to succeed. For more information, see Batch Operations and Error Handling in the Amazon DynamoDB Developer Guide. By default, BatchGetItem performs eventually consistent reads on every table in the request. If you want strongly consistent reads instead, you can set ConsistentRead to In order to minimize response latency, BatchGetItem retrieves items in parallel. When designing your application, keep in mind that DynamoDB does not return items in any particular order. To help parse the response by item, include the primary key values for the items in your request in the AttributesToGet parameter. If a requested item does not exist, it is not returned in the result. Requests for nonexistent items consume the minimum read capacity units according to the type of read. For more information, see Capacity Units Calculations in the Amazon DynamoDB Developer Guide.
|
|
|
BatchGetItemAsync ( |
Initiates the asynchronous execution of the BatchGetItem operation.
|
|
|
BatchGetItemAsync ( KeysAndAttributes>.Dictionary |
The BatchGetItem operation returns the attributes of one or more items from one or more tables. You identify requested items by primary key. A single operation can retrieve up to 16 MB of data, which can contain as many as 100 items. BatchGetItem will return a partial result if the response size limit is exceeded, the table's provisioned throughput is exceeded, or an internal processing failure occurs. If a partial result is returned, the operation returns a value for UnprocessedKeys. You can use this value to retry the operation starting with the next item to get. If you request more than 100 items BatchGetItem will return a ValidationException with the message "Too many items requested for the BatchGetItem call". For example, if you ask to retrieve 100 items, but each individual item is 300 KB in size, the system returns 52 items (so as not to exceed the 16 MB limit). It also returns an appropriate UnprocessedKeys value so you can get the next page of results. If desired, your application can include its own logic to assemble the pages of results into one data set. If none of the items can be processed due to insufficient provisioned throughput on all of the tables in the request, then BatchGetItem will return a ProvisionedThroughputExceededException. If at least one of the items is successfully processed, then BatchGetItem completes successfully, while returning the keys of the unread items in UnprocessedKeys. If DynamoDB returns any unprocessed items, you should retry the batch operation on those items. However, we strongly recommend that you use an exponential backoff algorithm. If you retry the batch operation immediately, the underlying read or write requests can still fail due to throttling on the individual tables. If you delay the batch operation using exponential backoff, the individual requests in the batch are much more likely to succeed. For more information, see Batch Operations and Error Handling in the Amazon DynamoDB Developer Guide. By default, BatchGetItem performs eventually consistent reads on every table in the request. If you want strongly consistent reads instead, you can set ConsistentRead to In order to minimize response latency, BatchGetItem retrieves items in parallel. When designing your application, keep in mind that DynamoDB does not return items in any particular order. To help parse the response by item, include the primary key values for the items in your request in the AttributesToGet parameter. If a requested item does not exist, it is not returned in the result. Requests for nonexistent items consume the minimum read capacity units according to the type of read. For more information, see Capacity Units Calculations in the Amazon DynamoDB Developer Guide.
|
|
|
BatchGetItemAsync ( KeysAndAttributes>.Dictionary |
The BatchGetItem operation returns the attributes of one or more items from one or more tables. You identify requested items by primary key. A single operation can retrieve up to 16 MB of data, which can contain as many as 100 items. BatchGetItem will return a partial result if the response size limit is exceeded, the table's provisioned throughput is exceeded, or an internal processing failure occurs. If a partial result is returned, the operation returns a value for UnprocessedKeys. You can use this value to retry the operation starting with the next item to get. If you request more than 100 items BatchGetItem will return a ValidationException with the message "Too many items requested for the BatchGetItem call". For example, if you ask to retrieve 100 items, but each individual item is 300 KB in size, the system returns 52 items (so as not to exceed the 16 MB limit). It also returns an appropriate UnprocessedKeys value so you can get the next page of results. If desired, your application can include its own logic to assemble the pages of results into one data set. If none of the items can be processed due to insufficient provisioned throughput on all of the tables in the request, then BatchGetItem will return a ProvisionedThroughputExceededException. If at least one of the items is successfully processed, then BatchGetItem completes successfully, while returning the keys of the unread items in UnprocessedKeys. If DynamoDB returns any unprocessed items, you should retry the batch operation on those items. However, we strongly recommend that you use an exponential backoff algorithm. If you retry the batch operation immediately, the underlying read or write requests can still fail due to throttling on the individual tables. If you delay the batch operation using exponential backoff, the individual requests in the batch are much more likely to succeed. For more information, see Batch Operations and Error Handling in the Amazon DynamoDB Developer Guide. By default, BatchGetItem performs eventually consistent reads on every table in the request. If you want strongly consistent reads instead, you can set ConsistentRead to In order to minimize response latency, BatchGetItem retrieves items in parallel. When designing your application, keep in mind that DynamoDB does not return items in any particular order. To help parse the response by item, include the primary key values for the items in your request in the AttributesToGet parameter. If a requested item does not exist, it is not returned in the result. Requests for nonexistent items consume the minimum read capacity units according to the type of read. For more information, see Capacity Units Calculations in the Amazon DynamoDB Developer Guide.
|
|
|
BatchWriteItem ( |
The BatchWriteItem operation puts or deletes multiple items in one or more tables. A single call to BatchWriteItem can write up to 16 MB of data, which can comprise as many as 25 put or delete requests. Individual items to be written can be as large as 400 KB. BatchWriteItem cannot update items. To update items, use the UpdateItem API. The individual PutItem and DeleteItem operations specified in BatchWriteItem are atomic; however BatchWriteItem as a whole is not. If any requested operations fail because the table's provisioned throughput is exceeded or an internal processing failure occurs, the failed operations are returned in the UnprocessedItems response parameter. You can investigate and optionally resend the requests. Typically, you would call BatchWriteItem in a loop. Each iteration would check for unprocessed items and submit a new BatchWriteItem request with those unprocessed items until all items have been processed. Note that if none of the items can be processed due to insufficient provisioned throughput on all of the tables in the request, then BatchWriteItem will return a ProvisionedThroughputExceededException. If DynamoDB returns any unprocessed items, you should retry the batch operation on those items. However, we strongly recommend that you use an exponential backoff algorithm. If you retry the batch operation immediately, the underlying read or write requests can still fail due to throttling on the individual tables. If you delay the batch operation using exponential backoff, the individual requests in the batch are much more likely to succeed. For more information, see Batch Operations and Error Handling in the Amazon DynamoDB Developer Guide. With BatchWriteItem, you can efficiently write or delete large amounts of data, such as from Amazon Elastic MapReduce (EMR), or copy data from another database into DynamoDB. In order to improve performance with these large-scale operations, BatchWriteItem does not behave in the same way as individual PutItem and DeleteItem calls would. For example, you cannot specify conditions on individual put and delete requests, and BatchWriteItem does not return deleted items in the response. If you use a programming language that supports concurrency, you can use threads to write items in parallel. Your application must include the necessary logic to manage the threads. With languages that don't support threading, you must update or delete the specified items one at a time. In both situations, BatchWriteItem 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. Parallel processing reduces latency, but each specified put and delete request consumes the same number of write capacity units whether it is processed in parallel or not. Delete operations on nonexistent items consume one write capacity unit. If one or more of the following is true, DynamoDB rejects the entire batch write operation:
|
|
|
BatchWriteItem ( Dictionary |
The BatchWriteItem operation puts or deletes multiple items in one or more tables. A single call to BatchWriteItem can write up to 16 MB of data, which can comprise as many as 25 put or delete requests. Individual items to be written can be as large as 400 KB. BatchWriteItem cannot update items. To update items, use the UpdateItem API. The individual PutItem and DeleteItem operations specified in BatchWriteItem are atomic; however BatchWriteItem as a whole is not. If any requested operations fail because the table's provisioned throughput is exceeded or an internal processing failure occurs, the failed operations are returned in the UnprocessedItems response parameter. You can investigate and optionally resend the requests. Typically, you would call BatchWriteItem in a loop. Each iteration would check for unprocessed items and submit a new BatchWriteItem request with those unprocessed items until all items have been processed. Note that if none of the items can be processed due to insufficient provisioned throughput on all of the tables in the request, then BatchWriteItem will return a ProvisionedThroughputExceededException. If DynamoDB returns any unprocessed items, you should retry the batch operation on those items. However, we strongly recommend that you use an exponential backoff algorithm. If you retry the batch operation immediately, the underlying read or write requests can still fail due to throttling on the individual tables. If you delay the batch operation using exponential backoff, the individual requests in the batch are much more likely to succeed. For more information, see Batch Operations and Error Handling in the Amazon DynamoDB Developer Guide. With BatchWriteItem, you can efficiently write or delete large amounts of data, such as from Amazon Elastic MapReduce (EMR), or copy data from another database into DynamoDB. In order to improve performance with these large-scale operations, BatchWriteItem does not behave in the same way as individual PutItem and DeleteItem calls would. For example, you cannot specify conditions on individual put and delete requests, and BatchWriteItem does not return deleted items in the response. If you use a programming language that supports concurrency, you can use threads to write items in parallel. Your application must include the necessary logic to manage the threads. With languages that don't support threading, you must update or delete the specified items one at a time. In both situations, BatchWriteItem 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. Parallel processing reduces latency, but each specified put and delete request consumes the same number of write capacity units whether it is processed in parallel or not. Delete operations on nonexistent items consume one write capacity unit. If one or more of the following is true, DynamoDB rejects the entire batch write operation:
|
|
|
BatchWriteItemAsync ( |
Initiates the asynchronous execution of the BatchWriteItem operation.
|
|
|
BatchWriteItemAsync ( Dictionary |
The BatchWriteItem operation puts or deletes multiple items in one or more tables. A single call to BatchWriteItem can write up to 16 MB of data, which can comprise as many as 25 put or delete requests. Individual items to be written can be as large as 400 KB. BatchWriteItem cannot update items. To update items, use the UpdateItem API. The individual PutItem and DeleteItem operations specified in BatchWriteItem are atomic; however BatchWriteItem as a whole is not. If any requested operations fail because the table's provisioned throughput is exceeded or an internal processing failure occurs, the failed operations are returned in the UnprocessedItems response parameter. You can investigate and optionally resend the requests. Typically, you would call BatchWriteItem in a loop. Each iteration would check for unprocessed items and submit a new BatchWriteItem request with those unprocessed items until all items have been processed. Note that if none of the items can be processed due to insufficient provisioned throughput on all of the tables in the request, then BatchWriteItem will return a ProvisionedThroughputExceededException. If DynamoDB returns any unprocessed items, you should retry the batch operation on those items. However, we strongly recommend that you use an exponential backoff algorithm. If you retry the batch operation immediately, the underlying read or write requests can still fail due to throttling on the individual tables. If you delay the batch operation using exponential backoff, the individual requests in the batch are much more likely to succeed. For more information, see Batch Operations and Error Handling in the Amazon DynamoDB Developer Guide. With BatchWriteItem, you can efficiently write or delete large amounts of data, such as from Amazon Elastic MapReduce (EMR), or copy data from another database into DynamoDB. In order to improve performance with these large-scale operations, BatchWriteItem does not behave in the same way as individual PutItem and DeleteItem calls would. For example, you cannot specify conditions on individual put and delete requests, and BatchWriteItem does not return deleted items in the response. If you use a programming language that supports concurrency, you can use threads to write items in parallel. Your application must include the necessary logic to manage the threads. With languages that don't support threading, you must update or delete the specified items one at a time. In both situations, BatchWriteItem 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. Parallel processing reduces latency, but each specified put and delete request consumes the same number of write capacity units whether it is processed in parallel or not. Delete operations on nonexistent items consume one write capacity unit. If one or more of the following is true, DynamoDB rejects the entire batch write operation:
|
|
|
BeginBatchGetItem ( |
Initiates the asynchronous execution of the BatchGetItem operation.
|
|
|
BeginBatchWriteItem ( |
Initiates the asynchronous execution of the BatchWriteItem operation.
|
|
|
BeginCreateTable ( |
Initiates the asynchronous execution of the CreateTable operation.
|
|
|
BeginDeleteItem ( |
Initiates the asynchronous execution of the DeleteItem operation.
|
|
|
BeginDeleteTable ( |
Initiates the asynchronous execution of the DeleteTable operation.
|
|
| BeginDescribeLimits ( DescribeLimitsRequest request, AsyncCallback callback, object state ) : IAsyncResult |
Initiates the asynchronous execution of the DescribeLimits operation.
|
|
|
BeginDescribeTable ( |
Initiates the asynchronous execution of the DescribeTable operation.
|
|
|
BeginGetItem ( |
Initiates the asynchronous execution of the GetItem operation.
|
|
|
BeginListTables ( |
Initiates the asynchronous execution of the ListTables operation.
|
|
|
BeginPutItem ( |
Initiates the asynchronous execution of the PutItem operation.
|
|
|
BeginQuery ( |
Initiates the asynchronous execution of the Query operation.
|
|
|
BeginScan ( |
Initiates the asynchronous execution of the Scan operation.
|
|
|
BeginUpdateItem ( |
Initiates the asynchronous execution of the UpdateItem operation.
|
|
|
BeginUpdateTable ( |
Initiates the asynchronous execution of the UpdateTable operation.
|
|
|
CreateTable ( |
The CreateTable operation adds a new table to your account. In an AWS account, table names must be unique within each region. That is, you can have two tables with same name if you create the tables in different regions. CreateTable is an asynchronous operation. Upon receiving a CreateTable request, DynamoDB immediately returns a response with a TableStatus of You can optionally define secondary indexes on the new table, as part of the CreateTable operation. If you want to create multiple tables with secondary indexes on them, you must create the tables sequentially. Only one table with secondary indexes can be in the You can use the DescribeTable API to check the table status.
|
|
|
CreateTable ( string tableName, List |
The CreateTable operation adds a new table to your account. In an AWS account, table names must be unique within each region. That is, you can have two tables with same name if you create the tables in different regions. CreateTable is an asynchronous operation. Upon receiving a CreateTable request, DynamoDB immediately returns a response with a TableStatus of You can optionally define secondary indexes on the new table, as part of the CreateTable operation. If you want to create multiple tables with secondary indexes on them, you must create the tables sequentially. Only one table with secondary indexes can be in the You can use the DescribeTable API to check the table status.
|
|
|
CreateTableAsync ( |
Initiates the asynchronous execution of the CreateTable operation.
|
|
|
CreateTableAsync ( string tableName, List |
The CreateTable operation adds a new table to your account. In an AWS account, table names must be unique within each region. That is, you can have two tables with same name if you create the tables in different regions. CreateTable is an asynchronous operation. Upon receiving a CreateTable request, DynamoDB immediately returns a response with a TableStatus of You can optionally define secondary indexes on the new table, as part of the CreateTable operation. If you want to create multiple tables with secondary indexes on them, you must create the tables sequentially. Only one table with secondary indexes can be in the You can use the DescribeTable API to check the table status.
|
|
|
DeleteItem ( |
Deletes a single item in a table by primary key. You can perform a conditional delete operation that deletes the item if it exists, or if it has an expected attribute value. In addition to deleting an item, you can also return the item's attribute values in the same operation, using the ReturnValues parameter. Unless you specify conditions, the DeleteItem is an idempotent operation; running it multiple times on the same item or attribute does not result in an error response. Conditional deletes are useful for deleting items only if specific conditions are met. If those conditions are met, DynamoDB performs the delete. Otherwise, the item is not deleted.
|
|
|
DeleteItem ( string tableName, AttributeValue>.Dictionary |
Deletes a single item in a table by primary key. You can perform a conditional delete operation that deletes the item if it exists, or if it has an expected attribute value. In addition to deleting an item, you can also return the item's attribute values in the same operation, using the ReturnValues parameter. Unless you specify conditions, the DeleteItem is an idempotent operation; running it multiple times on the same item or attribute does not result in an error response. Conditional deletes are useful for deleting items only if specific conditions are met. If those conditions are met, DynamoDB performs the delete. Otherwise, the item is not deleted.
|
|
|
DeleteItem ( string tableName, AttributeValue>.Dictionary |
Deletes a single item in a table by primary key. You can perform a conditional delete operation that deletes the item if it exists, or if it has an expected attribute value. In addition to deleting an item, you can also return the item's attribute values in the same operation, using the ReturnValues parameter. Unless you specify conditions, the DeleteItem is an idempotent operation; running it multiple times on the same item or attribute does not result in an error response. Conditional deletes are useful for deleting items only if specific conditions are met. If those conditions are met, DynamoDB performs the delete. Otherwise, the item is not deleted.
|
|
|
DeleteItemAsync ( |
Initiates the asynchronous execution of the DeleteItem operation.
|
|
|
DeleteItemAsync ( string tableName, AttributeValue>.Dictionary |
Deletes a single item in a table by primary key. You can perform a conditional delete operation that deletes the item if it exists, or if it has an expected attribute value. In addition to deleting an item, you can also return the item's attribute values in the same operation, using the ReturnValues parameter. Unless you specify conditions, the DeleteItem is an idempotent operation; running it multiple times on the same item or attribute does not result in an error response. Conditional deletes are useful for deleting items only if specific conditions are met. If those conditions are met, DynamoDB performs the delete. Otherwise, the item is not deleted.
|
|
|
DeleteItemAsync ( string tableName, AttributeValue>.Dictionary |
Deletes a single item in a table by primary key. You can perform a conditional delete operation that deletes the item if it exists, or if it has an expected attribute value. In addition to deleting an item, you can also return the item's attribute values in the same operation, using the ReturnValues parameter. Unless you specify conditions, the DeleteItem is an idempotent operation; running it multiple times on the same item or attribute does not result in an error response. Conditional deletes are useful for deleting items only if specific conditions are met. If those conditions are met, DynamoDB performs the delete. Otherwise, the item is not deleted.
|
|
|
DeleteTable ( |
The DeleteTable operation deletes a table and all of its items. After a DeleteTable request, the specified table is in the DynamoDB might continue to accept data read and write operations, such as GetItem and PutItem, on a table in the When you delete a table, any indexes on that table are also deleted. If you have DynamoDB Streams enabled on the table, then the corresponding stream on that table goes into the Use the DescribeTable API to check the status of the table.
|
|
|
DeleteTable ( string tableName ) : |
The DeleteTable operation deletes a table and all of its items. After a DeleteTable request, the specified table is in the DynamoDB might continue to accept data read and write operations, such as GetItem and PutItem, on a table in the When you delete a table, any indexes on that table are also deleted. If you have DynamoDB Streams enabled on the table, then the corresponding stream on that table goes into the Use the DescribeTable API to check the status of the table.
|
|
|
DeleteTableAsync ( |
Initiates the asynchronous execution of the DeleteTable operation.
|
|
|
DeleteTableAsync ( string tableName, System cancellationToken = default(CancellationToken) ) : Task |
The DeleteTable operation deletes a table and all of its items. After a DeleteTable request, the specified table is in the DynamoDB might continue to accept data read and write operations, such as GetItem and PutItem, on a table in the When you delete a table, any indexes on that table are also deleted. If you have DynamoDB Streams enabled on the table, then the corresponding stream on that table goes into the Use the DescribeTable API to check the status of the table.
|
|
|
DescribeLimits ( DescribeLimitsRequest request ) : |
Returns the current provisioned-capacity limits for your AWS account in a region, both for the region as a whole and for any one DynamoDB table that you create there. When you establish an AWS account, the account has initial limits on the maximum read capacity units and write capacity units that you can provision across all of your DynamoDB tables in a given region. Also, there are per-table limits that apply when you create a table there. For more information, see Limits page in the Amazon DynamoDB Developer Guide. Although you can increase these limits by filing a case at AWS Support Center, obtaining the increase is not instantaneous. The DescribeLimits API lets you write code to compare the capacity you are currently using to those limits imposed by your account so that you have enough time to apply for an increase before you hit a limit. For example, you could use one of the AWS SDKs to do the following:
This will let you see whether you are getting close to your account-level limits. The per-table limits apply only when you are creating a new table. They restrict the sum of the provisioned capacity of the new table itself and all its global secondary indexes. For existing tables and their GSIs, DynamoDB will not let you increase provisioned capacity extremely rapidly, but the only upper limit that applies is that the aggregate provisioned capacity over all your tables and GSIs cannot exceed either of the per-account limits. DescribeLimits should only be called periodically. You can expect throttling errors if you call it more than once in a minute. The DescribeLimits Request element has no content.
|
|
|
DescribeLimitsAsync ( DescribeLimitsRequest request, System cancellationToken = default(CancellationToken) ) : Task |
Initiates the asynchronous execution of the DescribeLimits operation.
|
|
|
DescribeTable ( |
Returns information about the table, including the current status of the table, when it was created, the primary key schema, and any indexes on the table. If you issue a DescribeTable request immediately after a CreateTable request, DynamoDB might return a ResourceNotFoundException. This is because DescribeTable uses an eventually consistent query, and the metadata for your table might not be available at that moment. Wait for a few seconds, and then try the DescribeTable request again.
|
|
|
DescribeTable ( string tableName ) : |
Returns information about the table, including the current status of the table, when it was created, the primary key schema, and any indexes on the table. If you issue a DescribeTable request immediately after a CreateTable request, DynamoDB might return a ResourceNotFoundException. This is because DescribeTable uses an eventually consistent query, and the metadata for your table might not be available at that moment. Wait for a few seconds, and then try the DescribeTable request again.
|
|
|
DescribeTableAsync ( |
Initiates the asynchronous execution of the DescribeTable operation.
|
|
|
DescribeTableAsync ( string tableName, System cancellationToken = default(CancellationToken) ) : Task |
Returns information about the table, including the current status of the table, when it was created, the primary key schema, and any indexes on the table. If you issue a DescribeTable request immediately after a CreateTable request, DynamoDB might return a ResourceNotFoundException. This is because DescribeTable uses an eventually consistent query, and the metadata for your table might not be available at that moment. Wait for a few seconds, and then try the DescribeTable request again.
|
|
|
EndBatchGetItem ( IAsyncResult asyncResult ) : |
Finishes the asynchronous execution of the BatchGetItem operation.
|
|
|
EndBatchWriteItem ( IAsyncResult asyncResult ) : |
Finishes the asynchronous execution of the BatchWriteItem operation.
|
|
|
EndCreateTable ( IAsyncResult asyncResult ) : |
Finishes the asynchronous execution of the CreateTable operation.
|
|
|
EndDeleteItem ( IAsyncResult asyncResult ) : |
Finishes the asynchronous execution of the DeleteItem operation.
|
|
|
EndDeleteTable ( IAsyncResult asyncResult ) : |
Finishes the asynchronous execution of the DeleteTable operation.
|
|
|
EndDescribeLimits ( IAsyncResult asyncResult ) : |
Finishes the asynchronous execution of the DescribeLimits operation.
|
|
|
EndDescribeTable ( IAsyncResult asyncResult ) : |
Finishes the asynchronous execution of the DescribeTable operation.
|
|
|
EndGetItem ( IAsyncResult asyncResult ) : |
Finishes the asynchronous execution of the GetItem operation.
|
|
|
EndListTables ( IAsyncResult asyncResult ) : |
Finishes the asynchronous execution of the ListTables operation.
|
|
|
EndPutItem ( IAsyncResult asyncResult ) : |
Finishes the asynchronous execution of the PutItem operation.
|
|
|
EndQuery ( IAsyncResult asyncResult ) : |
Finishes the asynchronous execution of the Query operation.
|
|
|
EndScan ( IAsyncResult asyncResult ) : |
Finishes the asynchronous execution of the Scan operation.
|
|
|
EndUpdateItem ( IAsyncResult asyncResult ) : |
Finishes the asynchronous execution of the UpdateItem operation.
|
|
|
EndUpdateTable ( IAsyncResult asyncResult ) : |
Finishes the asynchronous execution of the UpdateTable operation.
|
|
|
GetItem ( |
The GetItem operation returns a set of attributes for the item with the given primary key. If there is no matching item, GetItem does not return any data. GetItem provides an eventually consistent read by default. If your application requires a strongly consistent read, set ConsistentRead to
|
|
|
GetItem ( string tableName, AttributeValue>.Dictionary |
The GetItem operation returns a set of attributes for the item with the given primary key. If there is no matching item, GetItem does not return any data. GetItem provides an eventually consistent read by default. If your application requires a strongly consistent read, set ConsistentRead to
|
|
|
GetItem ( string tableName, AttributeValue>.Dictionary |
The GetItem operation returns a set of attributes for the item with the given primary key. If there is no matching item, GetItem does not return any data. GetItem provides an eventually consistent read by default. If your application requires a strongly consistent read, set ConsistentRead to
|
|
|
GetItemAsync ( |
Initiates the asynchronous execution of the GetItem operation.
|
|
|
GetItemAsync ( string tableName, AttributeValue>.Dictionary |
The GetItem operation returns a set of attributes for the item with the given primary key. If there is no matching item, GetItem does not return any data. GetItem provides an eventually consistent read by default. If your application requires a strongly consistent read, set ConsistentRead to
|
|
|
GetItemAsync ( string tableName, AttributeValue>.Dictionary |
The GetItem operation returns a set of attributes for the item with the given primary key. If there is no matching item, GetItem does not return any data. GetItem provides an eventually consistent read by default. If your application requires a strongly consistent read, set ConsistentRead to
|
|
|
ListTables ( ) : |
Returns an array of table names associated with the current account and endpoint. The output from ListTables is paginated, with each page returning a maximum of 100 table names.
|
|
|
ListTables ( |
Returns an array of table names associated with the current account and endpoint. The output from ListTables is paginated, with each page returning a maximum of 100 table names.
|
|
|
ListTables ( int limit ) : |
Returns an array of table names associated with the current account and endpoint. The output from ListTables is paginated, with each page returning a maximum of 100 table names.
|
|
|
ListTables ( string exclusiveStartTableName ) : |
Returns an array of table names associated with the current account and endpoint. The output from ListTables is paginated, with each page returning a maximum of 100 table names.
|
|
|
ListTables ( string exclusiveStartTableName, int limit ) : |
Returns an array of table names associated with the current account and endpoint. The output from ListTables is paginated, with each page returning a maximum of 100 table names.
|
|
|
ListTablesAsync ( |
Initiates the asynchronous execution of the ListTables operation.
|
|
|
ListTablesAsync ( System cancellationToken = default(CancellationToken) ) : Task |
Returns an array of table names associated with the current account and endpoint. The output from ListTables is paginated, with each page returning a maximum of 100 table names.
|
|
|
ListTablesAsync ( int limit, System cancellationToken = default(CancellationToken) ) : Task |
Returns an array of table names associated with the current account and endpoint. The output from ListTables is paginated, with each page returning a maximum of 100 table names.
|
|
|
ListTablesAsync ( string exclusiveStartTableName, System cancellationToken = default(CancellationToken) ) : Task |
Returns an array of table names associated with the current account and endpoint. The output from ListTables is paginated, with each page returning a maximum of 100 table names.
|
|
|
ListTablesAsync ( string exclusiveStartTableName, int limit, System cancellationToken = default(CancellationToken) ) : Task |
Returns an array of table names associated with the current account and endpoint. The output from ListTables is paginated, with each page returning a maximum of 100 table names.
|
|
|
PutItem ( |
Creates a new item, or replaces an old item with a new item. If an item that has the same primary key as the new item already exists in the specified table, the new item completely replaces the existing item. You can perform a conditional put operation (add a new item if one with the specified primary key doesn't exist), or replace an existing item if it has certain attribute values. In addition to putting an item, you can also return the item's attribute values in the same operation, using the ReturnValues parameter. When you add an item, the primary key attribute(s) are the only required attributes. Attribute values cannot be null. String and Binary type attributes must have lengths greater than zero. Set type attributes cannot be empty. Requests with empty values will be rejected with a ValidationException exception. You can request that PutItem return either a copy of the original item (before the update) or a copy of the updated item (after the update). For more information, see the ReturnValues description below. To prevent a new item from replacing an existing item, use a conditional expression that contains the For more information about using this API, see Working with Items in the Amazon DynamoDB Developer Guide.
|
|
|
PutItem ( string tableName, AttributeValue>.Dictionary |
Creates a new item, or replaces an old item with a new item. If an item that has the same primary key as the new item already exists in the specified table, the new item completely replaces the existing item. You can perform a conditional put operation (add a new item if one with the specified primary key doesn't exist), or replace an existing item if it has certain attribute values. In addition to putting an item, you can also return the item's attribute values in the same operation, using the ReturnValues parameter. When you add an item, the primary key attribute(s) are the only required attributes. Attribute values cannot be null. String and Binary type attributes must have lengths greater than zero. Set type attributes cannot be empty. Requests with empty values will be rejected with a ValidationException exception. You can request that PutItem return either a copy of the original item (before the update) or a copy of the updated item (after the update). For more information, see the ReturnValues description below. To prevent a new item from replacing an existing item, use a conditional expression that contains the For more information about using this API, see Working with Items in the Amazon DynamoDB Developer Guide.
|
|
|
PutItem ( string tableName, AttributeValue>.Dictionary |
Creates a new item, or replaces an old item with a new item. If an item that has the same primary key as the new item already exists in the specified table, the new item completely replaces the existing item. You can perform a conditional put operation (add a new item if one with the specified primary key doesn't exist), or replace an existing item if it has certain attribute values. In addition to putting an item, you can also return the item's attribute values in the same operation, using the ReturnValues parameter. When you add an item, the primary key attribute(s) are the only required attributes. Attribute values cannot be null. String and Binary type attributes must have lengths greater than zero. Set type attributes cannot be empty. Requests with empty values will be rejected with a ValidationException exception. You can request that PutItem return either a copy of the original item (before the update) or a copy of the updated item (after the update). For more information, see the ReturnValues description below. To prevent a new item from replacing an existing item, use a conditional expression that contains the For more information about using this API, see Working with Items in the Amazon DynamoDB Developer Guide.
|
|
|
PutItemAsync ( |
Initiates the asynchronous execution of the PutItem operation.
|
|
|
PutItemAsync ( string tableName, AttributeValue>.Dictionary |
Creates a new item, or replaces an old item with a new item. If an item that has the same primary key as the new item already exists in the specified table, the new item completely replaces the existing item. You can perform a conditional put operation (add a new item if one with the specified primary key doesn't exist), or replace an existing item if it has certain attribute values. In addition to putting an item, you can also return the item's attribute values in the same operation, using the ReturnValues parameter. When you add an item, the primary key attribute(s) are the only required attributes. Attribute values cannot be null. String and Binary type attributes must have lengths greater than zero. Set type attributes cannot be empty. Requests with empty values will be rejected with a ValidationException exception. You can request that PutItem return either a copy of the original item (before the update) or a copy of the updated item (after the update). For more information, see the ReturnValues description below. To prevent a new item from replacing an existing item, use a conditional expression that contains the For more information about using this API, see Working with Items in the Amazon DynamoDB Developer Guide.
|
|
|
PutItemAsync ( string tableName, AttributeValue>.Dictionary |
Creates a new item, or replaces an old item with a new item. If an item that has the same primary key as the new item already exists in the specified table, the new item completely replaces the existing item. You can perform a conditional put operation (add a new item if one with the specified primary key doesn't exist), or replace an existing item if it has certain attribute values. In addition to putting an item, you can also return the item's attribute values in the same operation, using the ReturnValues parameter. When you add an item, the primary key attribute(s) are the only required attributes. Attribute values cannot be null. String and Binary type attributes must have lengths greater than zero. Set type attributes cannot be empty. Requests with empty values will be rejected with a ValidationException exception. You can request that PutItem return either a copy of the original item (before the update) or a copy of the updated item (after the update). For more information, see the ReturnValues description below. To prevent a new item from replacing an existing item, use a conditional expression that contains the For more information about using this API, see Working with Items in the Amazon DynamoDB Developer Guide.
|
|
|
Query ( |
A Query operation uses the primary key of a table or a secondary index to directly access items from that table or index. Use the KeyConditionExpression parameter to provide a specific value for the partition key. The Query operation will return all of the items from the table or index with that partition key value. You can optionally narrow the scope of the Query operation by specifying a sort key value and a comparison operator in KeyConditionExpression. You can use the ScanIndexForward parameter to get results in forward or reverse order, by sort key. Queries that do not return results consume the minimum number of read capacity units for that type of read operation. If the total number of items meeting the query criteria exceeds the result set size limit of 1 MB, the query stops and results are returned to the user with the LastEvaluatedKey element to continue the query in a subsequent operation. Unlike a Scan operation, a Query operation never returns both an empty result set and a LastEvaluatedKey value. LastEvaluatedKey is only provided if you have used the Limit parameter, or if the result set exceeds 1 MB (prior to applying a filter). You can query a table, a local secondary index, or a global secondary index. For a query on a table or on a local secondary index, you can set the ConsistentRead parameter to
|
|
|
QueryAsync ( |
Initiates the asynchronous execution of the Query operation.
|
|
|
Scan ( |
The Scan operation returns one or more items and item attributes by accessing every item in a table or a secondary index. To have DynamoDB return fewer items, you can provide a ScanFilter operation. If the total number of scanned items exceeds the maximum data set size limit of 1 MB, the scan stops and results are returned to the user as a LastEvaluatedKey value to continue the scan in a subsequent operation. The results also include the number of items exceeding the limit. A scan can result in no table data meeting the filter criteria. By default, Scan operations proceed sequentially; however, for faster performance on a large table or secondary index, applications can request a parallel Scan operation by providing the Segment and TotalSegments parameters. For more information, see Parallel Scan in the Amazon DynamoDB Developer Guide. By default, Scan uses eventually consistent reads when accessing the data in a table; therefore, the result set might not include the changes to data in the table immediately before the operation began. If you need a consistent copy of the data, as of the time that the Scan begins, you can set the ConsistentRead parameter to true.
|
|
|
Scan ( string tableName, Condition>.Dictionary |
The Scan operation returns one or more items and item attributes by accessing every item in a table or a secondary index. To have DynamoDB return fewer items, you can provide a ScanFilter operation. If the total number of scanned items exceeds the maximum data set size limit of 1 MB, the scan stops and results are returned to the user as a LastEvaluatedKey value to continue the scan in a subsequent operation. The results also include the number of items exceeding the limit. A scan can result in no table data meeting the filter criteria. By default, Scan operations proceed sequentially; however, for faster performance on a large table or secondary index, applications can request a parallel Scan operation by providing the Segment and TotalSegments parameters. For more information, see Parallel Scan in the Amazon DynamoDB Developer Guide. By default, Scan uses eventually consistent reads when accessing the data in a table; therefore, the result set might not include the changes to data in the table immediately before the operation began. If you need a consistent copy of the data, as of the time that the Scan begins, you can set the ConsistentRead parameter to true.
|
|
|
Scan ( string tableName, List |
The Scan operation returns one or more items and item attributes by accessing every item in a table or a secondary index. To have DynamoDB return fewer items, you can provide a ScanFilter operation. If the total number of scanned items exceeds the maximum data set size limit of 1 MB, the scan stops and results are returned to the user as a LastEvaluatedKey value to continue the scan in a subsequent operation. The results also include the number of items exceeding the limit. A scan can result in no table data meeting the filter criteria. By default, Scan operations proceed sequentially; however, for faster performance on a large table or secondary index, applications can request a parallel Scan operation by providing the Segment and TotalSegments parameters. For more information, see Parallel Scan in the Amazon DynamoDB Developer Guide. By default, Scan uses eventually consistent reads when accessing the data in a table; therefore, the result set might not include the changes to data in the table immediately before the operation began. If you need a consistent copy of the data, as of the time that the Scan begins, you can set the ConsistentRead parameter to true.
|
|
|
Scan ( string tableName, List |
The Scan operation returns one or more items and item attributes by accessing every item in a table or a secondary index. To have DynamoDB return fewer items, you can provide a ScanFilter operation. If the total number of scanned items exceeds the maximum data set size limit of 1 MB, the scan stops and results are returned to the user as a LastEvaluatedKey value to continue the scan in a subsequent operation. The results also include the number of items exceeding the limit. A scan can result in no table data meeting the filter criteria. By default, Scan operations proceed sequentially; however, for faster performance on a large table or secondary index, applications can request a parallel Scan operation by providing the Segment and TotalSegments parameters. For more information, see Parallel Scan in the Amazon DynamoDB Developer Guide. By default, Scan uses eventually consistent reads when accessing the data in a table; therefore, the result set might not include the changes to data in the table immediately before the operation began. If you need a consistent copy of the data, as of the time that the Scan begins, you can set the ConsistentRead parameter to true.
|
|
|
ScanAsync ( |
Initiates the asynchronous execution of the Scan operation.
|
|
|
ScanAsync ( string tableName, Condition>.Dictionary |
The Scan operation returns one or more items and item attributes by accessing every item in a table or a secondary index. To have DynamoDB return fewer items, you can provide a ScanFilter operation. If the total number of scanned items exceeds the maximum data set size limit of 1 MB, the scan stops and results are returned to the user as a LastEvaluatedKey value to continue the scan in a subsequent operation. The results also include the number of items exceeding the limit. A scan can result in no table data meeting the filter criteria. By default, Scan operations proceed sequentially; however, for faster performance on a large table or secondary index, applications can request a parallel Scan operation by providing the Segment and TotalSegments parameters. For more information, see Parallel Scan in the Amazon DynamoDB Developer Guide. By default, Scan uses eventually consistent reads when accessing the data in a table; therefore, the result set might not include the changes to data in the table immediately before the operation began. If you need a consistent copy of the data, as of the time that the Scan begins, you can set the ConsistentRead parameter to true.
|
|
|
ScanAsync ( string tableName, List |
The Scan operation returns one or more items and item attributes by accessing every item in a table or a secondary index. To have DynamoDB return fewer items, you can provide a ScanFilter operation. If the total number of scanned items exceeds the maximum data set size limit of 1 MB, the scan stops and results are returned to the user as a LastEvaluatedKey value to continue the scan in a subsequent operation. The results also include the number of items exceeding the limit. A scan can result in no table data meeting the filter criteria. By default, Scan operations proceed sequentially; however, for faster performance on a large table or secondary index, applications can request a parallel Scan operation by providing the Segment and TotalSegments parameters. For more information, see Parallel Scan in the Amazon DynamoDB Developer Guide. By default, Scan uses eventually consistent reads when accessing the data in a table; therefore, the result set might not include the changes to data in the table immediately before the operation began. If you need a consistent copy of the data, as of the time that the Scan begins, you can set the ConsistentRead parameter to true.
|
|
|
ScanAsync ( string tableName, List |
The Scan operation returns one or more items and item attributes by accessing every item in a table or a secondary index. To have DynamoDB return fewer items, you can provide a ScanFilter operation. If the total number of scanned items exceeds the maximum data set size limit of 1 MB, the scan stops and results are returned to the user as a LastEvaluatedKey value to continue the scan in a subsequent operation. The results also include the number of items exceeding the limit. A scan can result in no table data meeting the filter criteria. By default, Scan operations proceed sequentially; however, for faster performance on a large table or secondary index, applications can request a parallel Scan operation by providing the Segment and TotalSegments parameters. For more information, see Parallel Scan in the Amazon DynamoDB Developer Guide. By default, Scan uses eventually consistent reads when accessing the data in a table; therefore, the result set might not include the changes to data in the table immediately before the operation began. If you need a consistent copy of the data, as of the time that the Scan begins, you can set the ConsistentRead parameter to true.
|
|
|
UpdateItem ( |
Edits an existing item's attributes, or adds a new item to the table if it does not already exist. You can put, delete, or add attribute values. You can also perform a conditional update on an existing item (insert a new attribute name-value pair if it doesn't exist, or replace an existing name-value pair if it has certain expected attribute values). You can also return the item's attribute values in the same UpdateItem operation using the ReturnValues parameter.
|
|
|
UpdateItem ( string tableName, AttributeValue>.Dictionary |
Edits an existing item's attributes, or adds a new item to the table if it does not already exist. You can put, delete, or add attribute values. You can also perform a conditional update on an existing item (insert a new attribute name-value pair if it doesn't exist, or replace an existing name-value pair if it has certain expected attribute values). You can also return the item's attribute values in the same UpdateItem operation using the ReturnValues parameter.
|
|
|
UpdateItem ( string tableName, AttributeValue>.Dictionary |
Edits an existing item's attributes, or adds a new item to the table if it does not already exist. You can put, delete, or add attribute values. You can also perform a conditional update on an existing item (insert a new attribute name-value pair if it doesn't exist, or replace an existing name-value pair if it has certain expected attribute values). You can also return the item's attribute values in the same UpdateItem operation using the ReturnValues parameter.
|
|
|
UpdateItemAsync ( |
Initiates the asynchronous execution of the UpdateItem operation.
|
|
|
UpdateItemAsync ( string tableName, AttributeValue>.Dictionary |
Edits an existing item's attributes, or adds a new item to the table if it does not already exist. You can put, delete, or add attribute values. You can also perform a conditional update on an existing item (insert a new attribute name-value pair if it doesn't exist, or replace an existing name-value pair if it has certain expected attribute values). You can also return the item's attribute values in the same UpdateItem operation using the ReturnValues parameter.
|
|
|
UpdateItemAsync ( string tableName, AttributeValue>.Dictionary |
Edits an existing item's attributes, or adds a new item to the table if it does not already exist. You can put, delete, or add attribute values. You can also perform a conditional update on an existing item (insert a new attribute name-value pair if it doesn't exist, or replace an existing name-value pair if it has certain expected attribute values). You can also return the item's attribute values in the same UpdateItem operation using the ReturnValues parameter.
|
|
|
UpdateTable ( |
Modifies the provisioned throughput settings, global secondary indexes, or DynamoDB Streams settings for a given table. You can only perform one of the following operations at once:
UpdateTable is an asynchronous operation; while it is executing, the table status changes from
|
|
|
UpdateTable ( string tableName, |
Modifies the provisioned throughput settings, global secondary indexes, or DynamoDB Streams settings for a given table. You can only perform one of the following operations at once:
UpdateTable is an asynchronous operation; while it is executing, the table status changes from
|
|
|
UpdateTableAsync ( |
Initiates the asynchronous execution of the UpdateTable operation.
|
|
|
UpdateTableAsync ( string tableName, |
Modifies the provisioned throughput settings, global secondary indexes, or DynamoDB Streams settings for a given table. You can only perform one of the following operations at once:
UpdateTable is an asynchronous operation; while it is executing, the table status changes from
|
| Method | Description | |
|---|---|---|
|
CreateSigner ( ) : |
Creates the signer for the service.
|
|
| CustomizeRuntimePipeline ( RuntimePipeline pipeline ) : void |
Customize the pipeline
|
|
| Dispose ( bool disposing ) : void |
Disposes the service client.
|
|
public AmazonDynamoDBClient ( |
||
| credentials | AWS Credentials | |
| return | System | |
|
public AmazonDynamoDBClient ( |
||
| credentials | AWS Credentials | |
| clientConfig | The AmazonDynamoDBClient Configuration Object | |
| return | System | |
|
public AmazonDynamoDBClient ( |
||
| credentials | AWS Credentials | |
| region | RegionEndpoint | The region to connect. |
| return | System | |
|
public AmazonDynamoDBClient ( |
||
| config | The AmazonDynamoDBClient Configuration Object | |
| return | System | |
| public AmazonDynamoDBClient ( RegionEndpoint region ) : System | ||
| region | RegionEndpoint | The region to connect. |
| return | System | |
| public AmazonDynamoDBClient ( string awsAccessKeyId, string awsSecretAccessKey ) : System | ||
| awsAccessKeyId | string | AWS Access Key ID |
| awsSecretAccessKey | string | AWS Secret Access Key |
| return | System | |
|
public AmazonDynamoDBClient ( string awsAccessKeyId, string awsSecretAccessKey, |
||
| awsAccessKeyId | string | AWS Access Key ID |
| awsSecretAccessKey | string | AWS Secret Access Key |
| clientConfig | The AmazonDynamoDBClient Configuration Object | |
| return | System | |
| public AmazonDynamoDBClient ( string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region ) : System | ||
| awsAccessKeyId | string | AWS Access Key ID |
| awsSecretAccessKey | string | AWS Secret Access Key |
| region | RegionEndpoint | The region to connect. |
| return | System | |
| public AmazonDynamoDBClient ( string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken ) : System | ||
| awsAccessKeyId | string | AWS Access Key ID |
| awsSecretAccessKey | string | AWS Secret Access Key |
| awsSessionToken | string | AWS Session Token |
| return | System | |
|
public AmazonDynamoDBClient ( string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, |
||
| awsAccessKeyId | string | AWS Access Key ID |
| awsSecretAccessKey | string | AWS Secret Access Key |
| awsSessionToken | string | AWS Session Token |
| clientConfig | The AmazonDynamoDBClient Configuration Object | |
| return | System | |
| public AmazonDynamoDBClient ( string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region ) : System | ||
| awsAccessKeyId | string | AWS Access Key ID |
| awsSecretAccessKey | string | AWS Secret Access Key |
| awsSessionToken | string | AWS Session Token |
| region | RegionEndpoint | The region to connect. |
| return | System | |
|
public BatchGetItem ( |
||
| request | Container for the necessary parameters to execute the BatchGetItem service method. | |
| return | ||
|
public BatchGetItem ( KeysAndAttributes>.Dictionary |
||
| requestItems | KeysAndAttributes>.Dictionary | A map of one or more table names and, for each table, a map that describes one or more items to retrieve from that table. Each table name can be used only once per BatchGetItem request. Each element in the map of items to retrieve consists of the following:
|
| return | ||
|
public BatchGetItem ( KeysAndAttributes>.Dictionary |
||
| requestItems | KeysAndAttributes>.Dictionary | A map of one or more table names and, for each table, a map that describes one or more items to retrieve from that table. Each table name can be used only once per BatchGetItem request. Each element in the map of items to retrieve consists of the following:
|
| returnConsumedCapacity | A property of BatchGetItemRequest used to execute the BatchGetItem service method. | |
| return | ||
|
public BatchGetItemAsync ( |
||
| request | Container for the necessary parameters to execute the BatchGetItem operation. | |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public BatchGetItemAsync ( KeysAndAttributes>.Dictionary |
||
| requestItems | KeysAndAttributes>.Dictionary | A map of one or more table names and, for each table, a map that describes one or more items to retrieve from that table. Each table name can be used only once per BatchGetItem request. Each element in the map of items to retrieve consists of the following:
|
| returnConsumedCapacity | A property of BatchGetItemRequest used to execute the BatchGetItem service method. | |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public BatchGetItemAsync ( KeysAndAttributes>.Dictionary |
||
| requestItems | KeysAndAttributes>.Dictionary | A map of one or more table names and, for each table, a map that describes one or more items to retrieve from that table. Each table name can be used only once per BatchGetItem request. Each element in the map of items to retrieve consists of the following:
|
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public BatchWriteItem ( |
||
| request | Container for the necessary parameters to execute the BatchWriteItem service method. | |
| return | ||
|
public BatchWriteItem ( Dictionary |
||
| requestItems | Dictionary |
A map of one or more table names and, for each table, a list of operations to be performed (DeleteRequest or PutRequest). Each element in the map consists of the following:
|
| return | ||
|
public BatchWriteItemAsync ( |
||
| request | Container for the necessary parameters to execute the BatchWriteItem operation. | |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public BatchWriteItemAsync ( Dictionary |
||
| requestItems | Dictionary |
A map of one or more table names and, for each table, a list of operations to be performed (DeleteRequest or PutRequest). Each element in the map consists of the following:
|
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public BeginBatchGetItem ( |
||
| request | Container for the necessary parameters to execute the BatchGetItem operation on AmazonDynamoDBClient. | |
| callback | AsyncCallback | An AsyncCallback delegate that is invoked when the operation completes. |
| state | object | A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. |
| return | IAsyncResult | |
|
public BeginBatchWriteItem ( |
||
| request | Container for the necessary parameters to execute the BatchWriteItem operation on AmazonDynamoDBClient. | |
| callback | AsyncCallback | An AsyncCallback delegate that is invoked when the operation completes. |
| state | object | A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. |
| return | IAsyncResult | |
|
public BeginCreateTable ( |
||
| request | Container for the necessary parameters to execute the CreateTable operation on AmazonDynamoDBClient. | |
| callback | AsyncCallback | An AsyncCallback delegate that is invoked when the operation completes. |
| state | object | A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. |
| return | IAsyncResult | |
|
public BeginDeleteItem ( |
||
| request | Container for the necessary parameters to execute the DeleteItem operation on AmazonDynamoDBClient. | |
| callback | AsyncCallback | An AsyncCallback delegate that is invoked when the operation completes. |
| state | object | A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. |
| return | IAsyncResult | |
|
public BeginDeleteTable ( |
||
| request | Container for the necessary parameters to execute the DeleteTable operation on AmazonDynamoDBClient. | |
| callback | AsyncCallback | An AsyncCallback delegate that is invoked when the operation completes. |
| state | object | A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. |
| return | IAsyncResult | |
| public BeginDescribeLimits ( DescribeLimitsRequest request, AsyncCallback callback, object state ) : IAsyncResult | ||
| request | DescribeLimitsRequest | Container for the necessary parameters to execute the DescribeLimits operation on AmazonDynamoDBClient. |
| callback | AsyncCallback | An AsyncCallback delegate that is invoked when the operation completes. |
| state | object | A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. |
| return | IAsyncResult | |
|
public BeginDescribeTable ( |
||
| request | Container for the necessary parameters to execute the DescribeTable operation on AmazonDynamoDBClient. | |
| callback | AsyncCallback | An AsyncCallback delegate that is invoked when the operation completes. |
| state | object | A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. |
| return | IAsyncResult | |
|
public BeginGetItem ( |
||
| request | Container for the necessary parameters to execute the GetItem operation on AmazonDynamoDBClient. | |
| callback | AsyncCallback | An AsyncCallback delegate that is invoked when the operation completes. |
| state | object | A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. |
| return | IAsyncResult | |
|
public BeginListTables ( |
||
| request | Container for the necessary parameters to execute the ListTables operation on AmazonDynamoDBClient. | |
| callback | AsyncCallback | An AsyncCallback delegate that is invoked when the operation completes. |
| state | object | A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. |
| return | IAsyncResult | |
|
public BeginPutItem ( |
||
| request | Container for the necessary parameters to execute the PutItem operation on AmazonDynamoDBClient. | |
| callback | AsyncCallback | An AsyncCallback delegate that is invoked when the operation completes. |
| state | object | A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. |
| return | IAsyncResult | |
|
public BeginQuery ( |
||
| request | Container for the necessary parameters to execute the Query operation on AmazonDynamoDBClient. | |
| callback | AsyncCallback | An AsyncCallback delegate that is invoked when the operation completes. |
| state | object | A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. |
| return | IAsyncResult | |
|
public BeginScan ( |
||
| request | Container for the necessary parameters to execute the Scan operation on AmazonDynamoDBClient. | |
| callback | AsyncCallback | An AsyncCallback delegate that is invoked when the operation completes. |
| state | object | A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. |
| return | IAsyncResult | |
|
public BeginUpdateItem ( |
||
| request | Container for the necessary parameters to execute the UpdateItem operation on AmazonDynamoDBClient. | |
| callback | AsyncCallback | An AsyncCallback delegate that is invoked when the operation completes. |
| state | object | A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. |
| return | IAsyncResult | |
|
public BeginUpdateTable ( |
||
| request | Container for the necessary parameters to execute the UpdateTable operation on AmazonDynamoDBClient. | |
| callback | AsyncCallback | An AsyncCallback delegate that is invoked when the operation completes. |
| state | object | A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. |
| return | IAsyncResult | |
|
protected CreateSigner ( ) : |
||
| return | ||
|
public CreateTable ( |
||
| request | Container for the necessary parameters to execute the CreateTable service method. | |
| return | ||
|
public CreateTable ( string tableName, List |
||
| tableName | string | The name of the table to create. |
| keySchema | List |
Specifies the attributes that make up the primary key for a table or an index. The attributes in KeySchema must also be defined in the AttributeDefinitions array. For more information, see Data Model in the Amazon DynamoDB Developer Guide. Each KeySchemaElement in the array is composed of:
HASH. For a composite primary key (partition key and sort key), you must provide exactly two elements, in this order: The first element must have a KeyType of HASH, and the second element must have a KeyType of RANGE. For more information, see Specifying the Primary Key in the Amazon DynamoDB Developer Guide. |
| attributeDefinitions | List |
An array of attributes that describe the key schema for the table and indexes. |
| provisionedThroughput | A property of CreateTableRequest used to execute the CreateTable service method. | |
| return | ||
|
public CreateTableAsync ( |
||
| request | Container for the necessary parameters to execute the CreateTable operation. | |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public CreateTableAsync ( string tableName, List |
||
| tableName | string | The name of the table to create. |
| keySchema | List |
Specifies the attributes that make up the primary key for a table or an index. The attributes in KeySchema must also be defined in the AttributeDefinitions array. For more information, see Data Model in the Amazon DynamoDB Developer Guide. Each KeySchemaElement in the array is composed of:
HASH. For a composite primary key (partition key and sort key), you must provide exactly two elements, in this order: The first element must have a KeyType of HASH, and the second element must have a KeyType of RANGE. For more information, see Specifying the Primary Key in the Amazon DynamoDB Developer Guide. |
| attributeDefinitions | List |
An array of attributes that describe the key schema for the table and indexes. |
| provisionedThroughput | A property of CreateTableRequest used to execute the CreateTable service method. | |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
| protected CustomizeRuntimePipeline ( RuntimePipeline pipeline ) : void | ||
| pipeline | RuntimePipeline | |
| return | void | |
|
public DeleteItem ( |
||
| request | Container for the necessary parameters to execute the DeleteItem service method. | |
| return | ||
|
public DeleteItem ( string tableName, AttributeValue>.Dictionary |
||
| tableName | string | The name of the table from which to delete the item. |
| key | AttributeValue>.Dictionary | A map of attribute names to AttributeValue objects, representing the primary key of the item to delete. For the primary key, you must provide all of the attributes. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide values for both the partition key and the sort key. |
| return | ||
|
public DeleteItem ( string tableName, AttributeValue>.Dictionary |
||
| tableName | string | The name of the table from which to delete the item. |
| key | AttributeValue>.Dictionary | A map of attribute names to AttributeValue objects, representing the primary key of the item to delete. For the primary key, you must provide all of the attributes. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide values for both the partition key and the sort key. |
| returnValues | Use ReturnValues if you want to get the item attributes as they appeared before they were deleted. For DeleteItem, the valid values are:
NONE or ALL_OLD. |
|
| return | ||
|
public DeleteItemAsync ( |
||
| request | Container for the necessary parameters to execute the DeleteItem operation. | |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public DeleteItemAsync ( string tableName, AttributeValue>.Dictionary |
||
| tableName | string | The name of the table from which to delete the item. |
| key | AttributeValue>.Dictionary | A map of attribute names to AttributeValue objects, representing the primary key of the item to delete. For the primary key, you must provide all of the attributes. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide values for both the partition key and the sort key. |
| returnValues | Use ReturnValues if you want to get the item attributes as they appeared before they were deleted. For DeleteItem, the valid values are:
NONE or ALL_OLD. |
|
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public DeleteItemAsync ( string tableName, AttributeValue>.Dictionary |
||
| tableName | string | The name of the table from which to delete the item. |
| key | AttributeValue>.Dictionary | A map of attribute names to AttributeValue objects, representing the primary key of the item to delete. For the primary key, you must provide all of the attributes. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide values for both the partition key and the sort key. |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public DeleteTable ( |
||
| request | Container for the necessary parameters to execute the DeleteTable service method. | |
| return | ||
|
public DeleteTable ( string tableName ) : |
||
| tableName | string | The name of the table to delete. |
| return | ||
|
public DeleteTableAsync ( |
||
| request | Container for the necessary parameters to execute the DeleteTable operation. | |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public DeleteTableAsync ( string tableName, System cancellationToken = default(CancellationToken) ) : Task |
||
| tableName | string | The name of the table to delete. |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public DescribeLimits ( DescribeLimitsRequest request ) : |
||
| request | DescribeLimitsRequest | Container for the necessary parameters to execute the DescribeLimits service method. |
| return | ||
|
public DescribeLimitsAsync ( DescribeLimitsRequest request, System cancellationToken = default(CancellationToken) ) : Task |
||
| request | DescribeLimitsRequest | Container for the necessary parameters to execute the DescribeLimits operation. |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public DescribeTable ( |
||
| request | Container for the necessary parameters to execute the DescribeTable service method. | |
| return | ||
|
public DescribeTable ( string tableName ) : |
||
| tableName | string | The name of the table to describe. |
| return | ||
|
public DescribeTableAsync ( |
||
| request | Container for the necessary parameters to execute the DescribeTable operation. | |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public DescribeTableAsync ( string tableName, System cancellationToken = default(CancellationToken) ) : Task |
||
| tableName | string | The name of the table to describe. |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public EndBatchGetItem ( IAsyncResult asyncResult ) : |
||
| asyncResult | IAsyncResult | The IAsyncResult returned by the call to BeginBatchGetItem. |
| return | ||
|
public EndBatchWriteItem ( IAsyncResult asyncResult ) : |
||
| asyncResult | IAsyncResult | The IAsyncResult returned by the call to BeginBatchWriteItem. |
| return | ||
|
public EndCreateTable ( IAsyncResult asyncResult ) : |
||
| asyncResult | IAsyncResult | The IAsyncResult returned by the call to BeginCreateTable. |
| return | ||
|
public EndDeleteItem ( IAsyncResult asyncResult ) : |
||
| asyncResult | IAsyncResult | The IAsyncResult returned by the call to BeginDeleteItem. |
| return | ||
|
public EndDeleteTable ( IAsyncResult asyncResult ) : |
||
| asyncResult | IAsyncResult | The IAsyncResult returned by the call to BeginDeleteTable. |
| return | ||
|
public EndDescribeLimits ( IAsyncResult asyncResult ) : |
||
| asyncResult | IAsyncResult | The IAsyncResult returned by the call to BeginDescribeLimits. |
| return | ||
|
public EndDescribeTable ( IAsyncResult asyncResult ) : |
||
| asyncResult | IAsyncResult | The IAsyncResult returned by the call to BeginDescribeTable. |
| return | ||
|
public EndGetItem ( IAsyncResult asyncResult ) : |
||
| asyncResult | IAsyncResult | The IAsyncResult returned by the call to BeginGetItem. |
| return | ||
|
public EndListTables ( IAsyncResult asyncResult ) : |
||
| asyncResult | IAsyncResult | The IAsyncResult returned by the call to BeginListTables. |
| return | ||
|
public EndPutItem ( IAsyncResult asyncResult ) : |
||
| asyncResult | IAsyncResult | The IAsyncResult returned by the call to BeginPutItem. |
| return | ||
|
public EndQuery ( IAsyncResult asyncResult ) : |
||
| asyncResult | IAsyncResult | The IAsyncResult returned by the call to BeginQuery. |
| return | ||
|
public EndScan ( IAsyncResult asyncResult ) : |
||
| asyncResult | IAsyncResult | The IAsyncResult returned by the call to BeginScan. |
| return | ||
|
public EndUpdateItem ( IAsyncResult asyncResult ) : |
||
| asyncResult | IAsyncResult | The IAsyncResult returned by the call to BeginUpdateItem. |
| return | ||
|
public EndUpdateTable ( IAsyncResult asyncResult ) : |
||
| asyncResult | IAsyncResult | The IAsyncResult returned by the call to BeginUpdateTable. |
| return | ||
|
public GetItem ( |
||
| request | Container for the necessary parameters to execute the GetItem service method. | |
| return | ||
|
public GetItem ( string tableName, AttributeValue>.Dictionary |
||
| tableName | string | The name of the table containing the requested item. |
| key | AttributeValue>.Dictionary | A map of attribute names to AttributeValue objects, representing the primary key of the item to retrieve. For the primary key, you must provide all of the attributes. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide values for both the partition key and the sort key. |
| return | ||
|
public GetItem ( string tableName, AttributeValue>.Dictionary |
||
| tableName | string | The name of the table containing the requested item. |
| key | AttributeValue>.Dictionary | A map of attribute names to AttributeValue objects, representing the primary key of the item to retrieve. For the primary key, you must provide all of the attributes. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide values for both the partition key and the sort key. |
| consistentRead | bool | Determines the read consistency model: If set to true, then the operation uses strongly consistent reads; otherwise, the operation uses eventually consistent reads. |
| return | ||
|
public GetItemAsync ( |
||
| request | Container for the necessary parameters to execute the GetItem operation. | |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public GetItemAsync ( string tableName, AttributeValue>.Dictionary |
||
| tableName | string | The name of the table containing the requested item. |
| key | AttributeValue>.Dictionary | A map of attribute names to AttributeValue objects, representing the primary key of the item to retrieve. For the primary key, you must provide all of the attributes. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide values for both the partition key and the sort key. |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public GetItemAsync ( string tableName, AttributeValue>.Dictionary |
||
| tableName | string | The name of the table containing the requested item. |
| key | AttributeValue>.Dictionary | A map of attribute names to AttributeValue objects, representing the primary key of the item to retrieve. For the primary key, you must provide all of the attributes. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide values for both the partition key and the sort key. |
| consistentRead | bool | Determines the read consistency model: If set to true, then the operation uses strongly consistent reads; otherwise, the operation uses eventually consistent reads. |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public ListTables ( ) : |
||
| return | ||
|
public ListTables ( |
||
| request | Container for the necessary parameters to execute the ListTables service method. | |
| return | ||
|
public ListTables ( int limit ) : |
||
| limit | int | A maximum number of table names to return. If this parameter is not specified, the limit is 100. |
| return | ||
|
public ListTables ( string exclusiveStartTableName ) : |
||
| exclusiveStartTableName | string | The first table name that this operation will evaluate. Use the value that was returned for LastEvaluatedTableName in a previous operation, so that you can obtain the next page of results. |
| return | ||
|
public ListTables ( string exclusiveStartTableName, int limit ) : |
||
| exclusiveStartTableName | string | The first table name that this operation will evaluate. Use the value that was returned for LastEvaluatedTableName in a previous operation, so that you can obtain the next page of results. |
| limit | int | A maximum number of table names to return. If this parameter is not specified, the limit is 100. |
| return | ||
|
public ListTablesAsync ( |
||
| request | Container for the necessary parameters to execute the ListTables operation. | |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public ListTablesAsync ( System cancellationToken = default(CancellationToken) ) : Task |
||
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public ListTablesAsync ( int limit, System cancellationToken = default(CancellationToken) ) : Task |
||
| limit | int | A maximum number of table names to return. If this parameter is not specified, the limit is 100. |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public ListTablesAsync ( string exclusiveStartTableName, System cancellationToken = default(CancellationToken) ) : Task |
||
| exclusiveStartTableName | string | The first table name that this operation will evaluate. Use the value that was returned for LastEvaluatedTableName in a previous operation, so that you can obtain the next page of results. |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public ListTablesAsync ( string exclusiveStartTableName, int limit, System cancellationToken = default(CancellationToken) ) : Task |
||
| exclusiveStartTableName | string | The first table name that this operation will evaluate. Use the value that was returned for LastEvaluatedTableName in a previous operation, so that you can obtain the next page of results. |
| limit | int | A maximum number of table names to return. If this parameter is not specified, the limit is 100. |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public PutItem ( |
||
| request | Container for the necessary parameters to execute the PutItem service method. | |
| return | ||
|
public PutItem ( string tableName, AttributeValue>.Dictionary |
||
| tableName | string | The name of the table to contain the item. |
| item | AttributeValue>.Dictionary | A map of attribute name/value pairs, one for each attribute. Only the primary key attributes are required; you can optionally provide other attribute name-value pairs for the item. You must provide all of the attributes for the primary key. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide both values for both the partition key and the sort key. If you specify any attributes that are part of an index key, then the data types for those attributes must match those of the schema in the table's attribute definition. For more information about primary keys, see Primary Key in the Amazon DynamoDB Developer Guide. Each element in the Item map is an AttributeValue object. |
| return | ||
|
public PutItem ( string tableName, AttributeValue>.Dictionary |
||
| tableName | string | The name of the table to contain the item. |
| item | AttributeValue>.Dictionary | A map of attribute name/value pairs, one for each attribute. Only the primary key attributes are required; you can optionally provide other attribute name-value pairs for the item. You must provide all of the attributes for the primary key. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide both values for both the partition key and the sort key. If you specify any attributes that are part of an index key, then the data types for those attributes must match those of the schema in the table's attribute definition. For more information about primary keys, see Primary Key in the Amazon DynamoDB Developer Guide. Each element in the Item map is an AttributeValue object. |
| returnValues | Use ReturnValues if you want to get the item attributes as they appeared before they were updated with the PutItem request. For PutItem, the valid values are:
NONE or ALL_OLD. |
|
| return | ||
|
public PutItemAsync ( |
||
| request | Container for the necessary parameters to execute the PutItem operation. | |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public PutItemAsync ( string tableName, AttributeValue>.Dictionary |
||
| tableName | string | The name of the table to contain the item. |
| item | AttributeValue>.Dictionary | A map of attribute name/value pairs, one for each attribute. Only the primary key attributes are required; you can optionally provide other attribute name-value pairs for the item. You must provide all of the attributes for the primary key. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide both values for both the partition key and the sort key. If you specify any attributes that are part of an index key, then the data types for those attributes must match those of the schema in the table's attribute definition. For more information about primary keys, see Primary Key in the Amazon DynamoDB Developer Guide. Each element in the Item map is an AttributeValue object. |
| returnValues | Use ReturnValues if you want to get the item attributes as they appeared before they were updated with the PutItem request. For PutItem, the valid values are:
NONE or ALL_OLD. |
|
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public PutItemAsync ( string tableName, AttributeValue>.Dictionary |
||
| tableName | string | The name of the table to contain the item. |
| item | AttributeValue>.Dictionary | A map of attribute name/value pairs, one for each attribute. Only the primary key attributes are required; you can optionally provide other attribute name-value pairs for the item. You must provide all of the attributes for the primary key. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide both values for both the partition key and the sort key. If you specify any attributes that are part of an index key, then the data types for those attributes must match those of the schema in the table's attribute definition. For more information about primary keys, see Primary Key in the Amazon DynamoDB Developer Guide. Each element in the Item map is an AttributeValue object. |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public Query ( |
||
| request | Container for the necessary parameters to execute the Query service method. | |
| return | ||
|
public QueryAsync ( |
||
| request | Container for the necessary parameters to execute the Query operation. | |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public Scan ( |
||
| request | Container for the necessary parameters to execute the Scan service method. | |
| return | ||
|
public Scan ( string tableName, Condition>.Dictionary |
||
| tableName | string | The name of the table containing the requested items; or, if you provide IndexName, the name of the table to which that index belongs. |
| scanFilter | Condition>.Dictionary |
|
| return | ||
|
public Scan ( string tableName, List |
||
| tableName | string | The name of the table containing the requested items; or, if you provide IndexName, the name of the table to which that index belongs. |
| attributesToGet | List |
|
| return | ||
|
public Scan ( string tableName, List |
||
| tableName | string | The name of the table containing the requested items; or, if you provide IndexName, the name of the table to which that index belongs. |
| attributesToGet | List |
|
| scanFilter | Condition>.Dictionary |
|
| return | ||
|
public ScanAsync ( |
||
| request | Container for the necessary parameters to execute the Scan operation. | |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public ScanAsync ( string tableName, Condition>.Dictionary |
||
| tableName | string | The name of the table containing the requested items; or, if you provide IndexName, the name of the table to which that index belongs. |
| scanFilter | Condition>.Dictionary |
|
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public ScanAsync ( string tableName, List |
||
| tableName | string | The name of the table containing the requested items; or, if you provide IndexName, the name of the table to which that index belongs. |
| attributesToGet | List |
|
| scanFilter | Condition>.Dictionary |
|
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public ScanAsync ( string tableName, List |
||
| tableName | string | The name of the table containing the requested items; or, if you provide IndexName, the name of the table to which that index belongs. |
| attributesToGet | List |
|
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public UpdateItem ( |
||
| request | Container for the necessary parameters to execute the UpdateItem service method. | |
| return | ||
|
public UpdateItem ( string tableName, AttributeValue>.Dictionary |
||
| tableName | string | The name of the table containing the item to update. |
| key | AttributeValue>.Dictionary | The primary key of the item to be updated. Each element consists of an attribute name and a value for that attribute. For the primary key, you must provide all of the attributes. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide values for both the partition key and the sort key. |
| attributeUpdates | AttributeValueUpdate>.Dictionary |
|
| return | ||
|
public UpdateItem ( string tableName, AttributeValue>.Dictionary |
||
| tableName | string | The name of the table containing the item to update. |
| key | AttributeValue>.Dictionary | The primary key of the item to be updated. Each element consists of an attribute name and a value for that attribute. For the primary key, you must provide all of the attributes. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide values for both the partition key and the sort key. |
| attributeUpdates | AttributeValueUpdate>.Dictionary |
|
| returnValues | Use ReturnValues if you want to get the item attributes as they appeared either before or after they were updated. For UpdateItem, the valid values are:
|
|
| return | ||
|
public UpdateItemAsync ( |
||
| request | Container for the necessary parameters to execute the UpdateItem operation. | |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public UpdateItemAsync ( string tableName, AttributeValue>.Dictionary |
||
| tableName | string | The name of the table containing the item to update. |
| key | AttributeValue>.Dictionary | The primary key of the item to be updated. Each element consists of an attribute name and a value for that attribute. For the primary key, you must provide all of the attributes. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide values for both the partition key and the sort key. |
| attributeUpdates | AttributeValueUpdate>.Dictionary |
|
| returnValues | Use ReturnValues if you want to get the item attributes as they appeared either before or after they were updated. For UpdateItem, the valid values are:
|
|
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public UpdateItemAsync ( string tableName, AttributeValue>.Dictionary |
||
| tableName | string | The name of the table containing the item to update. |
| key | AttributeValue>.Dictionary | The primary key of the item to be updated. Each element consists of an attribute name and a value for that attribute. For the primary key, you must provide all of the attributes. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide values for both the partition key and the sort key. |
| attributeUpdates | AttributeValueUpdate>.Dictionary |
|
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public UpdateTable ( |
||
| request | Container for the necessary parameters to execute the UpdateTable service method. | |
| return | ||
|
public UpdateTable ( string tableName, |
||
| tableName | string | The name of the table to be updated. |
| provisionedThroughput | A property of UpdateTableRequest used to execute the UpdateTable service method. | |
| return | ||
|
public UpdateTableAsync ( |
||
| request | Container for the necessary parameters to execute the UpdateTable operation. | |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
|
public UpdateTableAsync ( string tableName, |
||
| tableName | string | The name of the table to be updated. |
| provisionedThroughput | A property of UpdateTableRequest used to execute the UpdateTable service method. | |
| cancellationToken | System | /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// |
| return | Task |
|
