com.amazonaws.services.dynamodbv2.AmazonDynamoDBAsyncClient Maven / Gradle / Ivy
/*
* Copyright 2010-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package com.amazonaws.services.dynamodbv2;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.handlers.AsyncHandler;
import com.amazonaws.ClientConfiguration;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.services.dynamodbv2.model.*;
/**
* Asynchronous client for accessing AmazonDynamoDBv2.
* All asynchronous calls made using this client are non-blocking. Callers could either
* process the result and handle the exceptions in the worker thread by providing a callback handler
* when making the call, or use the returned Future object to check the result of the call in the calling thread.
* Amazon DynamoDB
* This is the Amazon DynamoDB API Reference. This guide provides
* descriptions of the low-level DynamoDB API.
*
*
* This guide is intended for use with the following DynamoDB
* documentation:
*
*
*
* -
*
* Amazon DynamoDB Getting Started Guide
* - provides hands-on exercises that help you learn the basics of
* working with DynamoDB. If you are new to DynamoDB, we recommend
* that you begin with the Getting Started Guide.
*
*
* -
*
* Amazon DynamoDB Developer Guide
* - contains detailed information about DynamoDB concepts, usage, and
* best practices.
*
*
* -
*
* Amazon DynamoDB Streams API Reference - provides descriptions and samples of the DynamoDB Streams API. (For more information, see Capturing Table Activity with DynamoDB Streams
* in the Amazon DynamoDB Developer Guide.)
*
*
*
*
*
* Instead of making the requests to the low-level DynamoDB API directly
* from your application, we recommend that you use the AWS Software
* Development Kits (SDKs). The easy-to-use libraries in the AWS SDKs
* make it unnecessary to call the low-level DynamoDB API directly from
* your application. The libraries take care of request authentication,
* serialization, and connection management. For more information, see
* Using the AWS SDKs with DynamoDB
* in the Amazon DynamoDB Developer Guide.
*
*
* If you decide to code against the low-level DynamoDB API directly, you
* will need to write the necessary code to authenticate your requests.
* For more information on signing your requests, see
* Using the DynamoDB API
* in the Amazon DynamoDB Developer Guide .
*
*
* The following are short descriptions of each low-level API action,
* organized by function.
*
*
* Managing Tables
*
*
*
* -
* CreateTable - Creates a table with user-specified provisioned
* throughput settings. You must define a primary key for the table -
* either a simple primary key (partition key), or a composite primary
* key (partition key and sort key). Optionally, you can create one or
* more secondary indexes, which provide fast data access using non-key
* attributes.
*
*
* -
* DescribeTable - Returns metadata for a table, such as table
* size, status, and index information.
*
*
* -
* UpdateTable - Modifies the provisioned throughput settings for
* a table. Optionally, you can modify the provisioned throughput
* settings for global secondary indexes on the table.
*
*
* -
* ListTables - Returns a list of all tables associated with the
* current AWS account and endpoint.
*
*
* -
* DeleteTable - Deletes a table and all of its indexes.
*
*
*
*
*
* For conceptual information about managing tables, see
* Working with Tables
* in the Amazon DynamoDB Developer Guide .
*
*
* Reading Data
*
*
*
* -
* GetItem - Returns a set of attributes for the item that has a
* given primary key. By default, GetItem performs an eventually
* consistent read; however, applications can request a strongly
* consistent read instead.
*
*
* -
* BatchGetItem - Performs multiple GetItem requests for
* data items using their primary keys, from one table or multiple
* tables. The response from BatchGetItem has a size limit of 16
* MB and returns a maximum of 100 items. Both eventually consistent and
* strongly consistent reads can be used.
*
*
* -
* Query - Returns one or more items from a table or a secondary
* index. You must provide a specific value for the partition key. You
* can narrow the scope of the query using comparison operators against a
* sort key value, or on the index key. Query supports either
* eventual or strong consistency. A single response has a size limit of
* 1 MB.
*
*
* -
* Scan - Reads every item in a table; the result set is
* eventually consistent. You can limit the number of items returned by
* filtering the data attributes, using conditional expressions.
* Scan can be used to enable ad-hoc querying of a table against
* non-key attributes; however, since this is a full table scan without
* using an index, Scan should not be used for any application
* query use case that requires predictable performance.
*
*
*
*
*
* For conceptual information about reading data, see
* Working with Items and Query and Scan Operations
* in the Amazon DynamoDB Developer Guide .
*
*
* Modifying Data
*
*
*
* -
* PutItem - Creates a new item, or replaces an existing item
* with a new item (including all the attributes). By default, if an item
* in the table already exists with the same primary key, the new item
* completely replaces the existing item. You can use conditional
* operators to replace an item only if its attribute values match
* certain conditions, or to insert a new item only if that item doesn't
* already exist.
*
*
* -
* UpdateItem - Modifies the attributes of an existing item. You
* can also use conditional operators to perform an update only if the
* item's attribute values match certain conditions.
*
*
* -
* DeleteItem - Deletes an item in a table by primary key. You
* can use conditional operators to perform a delete an item only if the
* item's attribute values match certain conditions.
*
*
* -
* BatchWriteItem - Performs multiple PutItem and
* DeleteItem requests across multiple tables in a single request.
* A failure of any request(s) in the batch will not cause the entire
* BatchWriteItem operation to fail. Supports batches of up to 25
* items to put or delete, with a maximum total request size of 16 MB.
*
*
*
*
*
* For conceptual information about modifying data, see
* Working with Items and Query and Scan Operations
* in the Amazon DynamoDB Developer Guide .
*
*/
public class AmazonDynamoDBAsyncClient extends AmazonDynamoDBClient
implements AmazonDynamoDBAsync {
/**
* Executor service for executing asynchronous requests.
*/
private ExecutorService executorService;
private static final int DEFAULT_THREAD_POOL_SIZE = 10;
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonDynamoDBv2. A credentials provider chain will be used
* that searches for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
*
* All service calls made using this new client object are blocking, and will not
* return until the service call completes.
*
* @see DefaultAWSCredentialsProviderChain
*/
@Deprecated
public AmazonDynamoDBAsyncClient() {
this(new DefaultAWSCredentialsProviderChain());
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonDynamoDBv2. A credentials provider chain will be used
* that searches for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
*
* All service calls made using this new client object are blocking, and will not
* return until the service call completes.
*
* @param clientConfiguration The client configuration options controlling how this
* client connects to AmazonDynamoDBv2
* (ex: proxy settings, retry counts, etc.).
*
* @see DefaultAWSCredentialsProviderChain
*/
@Deprecated
public AmazonDynamoDBAsyncClient(ClientConfiguration clientConfiguration) {
this(new DefaultAWSCredentialsProviderChain(), clientConfiguration, Executors.newFixedThreadPool(clientConfiguration.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonDynamoDBv2 using the specified AWS account credentials.
* Default client settings will be used, and a fixed size thread pool will be
* created for executing the asynchronous tasks.
*
*
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @param awsCredentials The AWS credentials (access key ID and secret key) to use
* when authenticating with AWS services.
*/
public AmazonDynamoDBAsyncClient(AWSCredentials awsCredentials) {
this(awsCredentials, Executors.newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonDynamoDBv2 using the specified AWS account credentials
* and executor service. Default client settings will be used.
*
*
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use
* when authenticating with AWS services.
* @param executorService
* The executor service by which all asynchronous requests will
* be executed.
*/
public AmazonDynamoDBAsyncClient(AWSCredentials awsCredentials, ExecutorService executorService) {
super(awsCredentials);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonDynamoDBv2 using the specified AWS account credentials,
* executor service, and client configuration options.
*
*
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use
* when authenticating with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy
* settings, etc).
* @param executorService
* The executor service by which all asynchronous requests will
* be executed.
*/
public AmazonDynamoDBAsyncClient(AWSCredentials awsCredentials,
ClientConfiguration clientConfiguration, ExecutorService executorService) {
super(awsCredentials, clientConfiguration);
this.executorService = executorService;
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonDynamoDBv2 using the specified AWS account credentials provider.
* Default client settings will be used, and a fixed size thread pool will be
* created for executing the asynchronous tasks.
*
*
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials
* to authenticate requests with AWS services.
*/
public AmazonDynamoDBAsyncClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, Executors.newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonDynamoDBv2 using the specified AWS account credentials provider
* and executor service. Default client settings will be used.
*
*
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials
* to authenticate requests with AWS services.
* @param executorService
* The executor service by which all asynchronous requests will
* be executed.
*/
public AmazonDynamoDBAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ExecutorService executorService) {
this(awsCredentialsProvider, new ClientConfiguration(), executorService);
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonDynamoDBv2 using the specified AWS account credentials
* provider and client configuration options.
*
*
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials
* to authenticate requests with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy
* settings, etc).
*/
public AmazonDynamoDBAsyncClient(AWSCredentialsProvider awsCredentialsProvider,
ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, Executors.newFixedThreadPool(clientConfiguration.getMaxConnections()));
}
/**
* Constructs a new asynchronous client to invoke service methods on
* AmazonDynamoDBv2 using the specified AWS account credentials
* provider, executor service, and client configuration options.
*
*
* All calls made using this new client object are non-blocking, and will immediately
* return a Java Future object that the caller can later check to see if the service
* call has actually completed.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials
* to authenticate requests with AWS services.
* @param clientConfiguration
* Client configuration options (ex: max retry limit, proxy
* settings, etc).
* @param executorService
* The executor service by which all asynchronous requests will
* be executed.
*/
public AmazonDynamoDBAsyncClient(AWSCredentialsProvider awsCredentialsProvider,
ClientConfiguration clientConfiguration, ExecutorService executorService) {
super(awsCredentialsProvider, clientConfiguration);
this.executorService = executorService;
}
/**
* Returns the executor service used by this async client to execute
* requests.
*
* @return The executor service used by this async client to execute
* requests.
*/
public ExecutorService getExecutorService() {
return executorService;
}
/**
* Shuts down the client, releasing all managed resources. This includes
* forcibly terminating all pending asynchronous service calls. Clients who
* wish to give pending asynchronous service calls time to complete should
* call getExecutorService().shutdown() followed by
* getExecutorService().awaitTermination() prior to calling this method.
*/
@Override
public void shutdown() {
super.shutdown();
executorService.shutdownNow();
}
/**
*
* The CreateTable operation adds a new table to your account. In
* an AWS account, table names must be unique within each region. That
* is, you can have two tables with same name if you create the tables in
* different regions.
*
*
* CreateTable is an asynchronous operation. Upon receiving a
* CreateTable request, DynamoDB immediately returns a response
* with a TableStatus of CREATING . After the table
* is created, DynamoDB sets the TableStatus to
* ACTIVE . You can perform read and write operations only
* on an ACTIVE table.
*
*
* You can optionally define secondary indexes on the new table, as part
* of the CreateTable operation. If you want to create multiple
* tables with secondary indexes on them, you must create the tables
* sequentially. Only one table with secondary indexes can be in the
* CREATING state at any given time.
*
*
* You can use the DescribeTable API to check the table status.
*
*
* @param createTableRequest Container for the necessary parameters to
* execute the CreateTable operation on AmazonDynamoDBv2.
*
* @return A Java Future object containing the response from the
* CreateTable service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future createTableAsync(final CreateTableRequest createTableRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public CreateTableResult call() throws Exception {
return createTable(createTableRequest);
}
});
}
/**
*
* The CreateTable operation adds a new table to your account. In
* an AWS account, table names must be unique within each region. That
* is, you can have two tables with same name if you create the tables in
* different regions.
*
*
* CreateTable is an asynchronous operation. Upon receiving a
* CreateTable request, DynamoDB immediately returns a response
* with a TableStatus of CREATING . After the table
* is created, DynamoDB sets the TableStatus to
* ACTIVE . You can perform read and write operations only
* on an ACTIVE table.
*
*
* You can optionally define secondary indexes on the new table, as part
* of the CreateTable operation. If you want to create multiple
* tables with secondary indexes on them, you must create the tables
* sequentially. Only one table with secondary indexes can be in the
* CREATING state at any given time.
*
*
* You can use the DescribeTable API to check the table status.
*
*
* @param createTableRequest Container for the necessary parameters to
* execute the CreateTable operation on AmazonDynamoDBv2.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* CreateTable service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future createTableAsync(
final CreateTableRequest createTableRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public CreateTableResult call() throws Exception {
CreateTableResult result;
try {
result = createTable(createTableRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(createTableRequest, result);
return result;
}
});
}
/**
*
* 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 .
*
*
* @param scanRequest Container for the necessary parameters to execute
* the Scan operation on AmazonDynamoDBv2.
*
* @return A Java Future object containing the response from the Scan
* service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future scanAsync(final ScanRequest scanRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ScanResult call() throws Exception {
return scan(scanRequest);
}
});
}
/**
*
* 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 .
*
*
* @param scanRequest Container for the necessary parameters to execute
* the Scan operation on AmazonDynamoDBv2.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the Scan
* service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future scanAsync(
final ScanRequest scanRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ScanResult call() throws Exception {
ScanResult result;
try {
result = scan(scanRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(scanRequest, result);
return result;
}
});
}
/**
*
* 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:
*
* - Call DescribeLimits for a particular region to obtain
* your current account limits on provisioned capacity there.
* - Create a variable to hold the aggregate read capacity units
* provisioned for all your tables in that region, and one to hold the
* aggregate write capacity units. Zero them both.
* - Call ListTables to obtain a list of all your DynamoDB
* tables.
* -
* For each table name listed by ListTables , do the following:
*
*
*
* - Call DescribeTable with the table name.
* - Use the data returned by DescribeTable to add the read
* capacity units and write capacity units provisioned for the table
* itself to your variables.
* - If the table has one or more global secondary indexes (GSIs),
* loop over these GSIs and add their provisioned capacity values to your
* variables as well.
*
*
*
* - Report the account limits for that region returned by
* DescribeLimits , along with the total current provisioned
* capacity levels you have calculated.
*
* 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.
*
*
* NOTE: 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.
*
*
* @param describeLimitsRequest Container for the necessary parameters to
* execute the DescribeLimits operation on AmazonDynamoDBv2.
*
* @return A Java Future object containing the response from the
* DescribeLimits service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future describeLimitsAsync(final DescribeLimitsRequest describeLimitsRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DescribeLimitsResult call() throws Exception {
return describeLimits(describeLimitsRequest);
}
});
}
/**
*
* 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:
*
* - Call DescribeLimits for a particular region to obtain
* your current account limits on provisioned capacity there.
* - Create a variable to hold the aggregate read capacity units
* provisioned for all your tables in that region, and one to hold the
* aggregate write capacity units. Zero them both.
* - Call ListTables to obtain a list of all your DynamoDB
* tables.
* -
* For each table name listed by ListTables , do the following:
*
*
*
* - Call DescribeTable with the table name.
* - Use the data returned by DescribeTable to add the read
* capacity units and write capacity units provisioned for the table
* itself to your variables.
* - If the table has one or more global secondary indexes (GSIs),
* loop over these GSIs and add their provisioned capacity values to your
* variables as well.
*
*
*
* - Report the account limits for that region returned by
* DescribeLimits , along with the total current provisioned
* capacity levels you have calculated.
*
* 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.
*
*
* NOTE: 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.
*
*
* @param describeLimitsRequest Container for the necessary parameters to
* execute the DescribeLimits operation on AmazonDynamoDBv2.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DescribeLimits service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future describeLimitsAsync(
final DescribeLimitsRequest describeLimitsRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DescribeLimitsResult call() throws Exception {
DescribeLimitsResult result;
try {
result = describeLimits(describeLimitsRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(describeLimitsRequest, result);
return result;
}
});
}
/**
*
* 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.
*
*
* IMPORTANT: 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 .
*
*
* IMPORTANT: If DynamoDB returns any unprocessed items, you
* should retry the batch operation on those items. However, we strongly
* recommend that you use an exponential backoff algorithm. If you retry
* the batch operation immediately, the underlying read or write requests
* can still fail due to throttling on the individual tables. If you
* delay the batch operation using exponential backoff, the individual
* requests in the batch are much more likely to succeed. For more
* information, see Batch Operations and Error Handling in the Amazon
* DynamoDB Developer Guide.
*
*
* By default, BatchGetItem performs eventually consistent reads
* on every table in the request. If you want strongly consistent reads
* instead, you can set ConsistentRead to true for
* any or all tables.
*
*
* In order to minimize response latency, BatchGetItem retrieves
* items in parallel.
*
*
* When designing your application, keep in mind that DynamoDB does not
* return attributes 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 .
*
*
* @param batchGetItemRequest Container for the necessary parameters to
* execute the BatchGetItem operation on AmazonDynamoDBv2.
*
* @return A Java Future object containing the response from the
* BatchGetItem service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future batchGetItemAsync(final BatchGetItemRequest batchGetItemRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public BatchGetItemResult call() throws Exception {
return batchGetItem(batchGetItemRequest);
}
});
}
/**
*
* 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.
*
*
* IMPORTANT: 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 .
*
*
* IMPORTANT: If DynamoDB returns any unprocessed items, you
* should retry the batch operation on those items. However, we strongly
* recommend that you use an exponential backoff algorithm. If you retry
* the batch operation immediately, the underlying read or write requests
* can still fail due to throttling on the individual tables. If you
* delay the batch operation using exponential backoff, the individual
* requests in the batch are much more likely to succeed. For more
* information, see Batch Operations and Error Handling in the Amazon
* DynamoDB Developer Guide.
*
*
* By default, BatchGetItem performs eventually consistent reads
* on every table in the request. If you want strongly consistent reads
* instead, you can set ConsistentRead to true for
* any or all tables.
*
*
* In order to minimize response latency, BatchGetItem retrieves
* items in parallel.
*
*
* When designing your application, keep in mind that DynamoDB does not
* return attributes 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 .
*
*
* @param batchGetItemRequest Container for the necessary parameters to
* execute the BatchGetItem operation on AmazonDynamoDBv2.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* BatchGetItem service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future batchGetItemAsync(
final BatchGetItemRequest batchGetItemRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public BatchGetItemResult call() throws Exception {
BatchGetItemResult result;
try {
result = batchGetItem(batchGetItemRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(batchGetItemRequest, result);
return result;
}
});
}
/**
*
* 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 true . Although a strongly
* consistent read might take more time than an eventually consistent
* read, it always returns the last updated value.
*
*
* @param getItemRequest Container for the necessary parameters to
* execute the GetItem operation on AmazonDynamoDBv2.
*
* @return A Java Future object containing the response from the GetItem
* service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getItemAsync(final GetItemRequest getItemRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetItemResult call() throws Exception {
return getItem(getItemRequest);
}
});
}
/**
*
* 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 true . Although a strongly
* consistent read might take more time than an eventually consistent
* read, it always returns the last updated value.
*
*
* @param getItemRequest Container for the necessary parameters to
* execute the GetItem operation on AmazonDynamoDBv2.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the GetItem
* service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future getItemAsync(
final GetItemRequest getItemRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public GetItemResult call() throws Exception {
GetItemResult result;
try {
result = getItem(getItemRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(getItemRequest, result);
return result;
}
});
}
/**
*
* 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.
*
*
* @param listTablesRequest Container for the necessary parameters to
* execute the ListTables operation on AmazonDynamoDBv2.
*
* @return A Java Future object containing the response from the
* ListTables service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listTablesAsync(final ListTablesRequest listTablesRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListTablesResult call() throws Exception {
return listTables(listTablesRequest);
}
});
}
/**
*
* 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.
*
*
* @param listTablesRequest Container for the necessary parameters to
* execute the ListTables operation on AmazonDynamoDBv2.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* ListTables service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future listTablesAsync(
final ListTablesRequest listTablesRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public ListTablesResult call() throws Exception {
ListTablesResult result;
try {
result = listTables(listTablesRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(listTablesRequest, result);
return result;
}
});
}
/**
*
* 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.
*
*
* NOTE: 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 .
*
*
* IMPORTANT: 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:
*
*
*
* -
* One or more tables specified in the BatchWriteItem request
* does not exist.
*
*
* -
* Primary key attributes specified on an item in the request do not
* match those in the corresponding table's primary key schema.
*
*
* -
* You try to perform multiple operations on the same item in the same
* BatchWriteItem request. For example, you cannot put and delete
* the same item in the same BatchWriteItem request.
*
*
* -
* There are more than 25 requests in the batch.
*
*
* -
* Any individual item in a batch exceeds 400 KB.
*
*
* -
* The total request size exceeds 16 MB.
*
*
*
*
*
* @param batchWriteItemRequest Container for the necessary parameters to
* execute the BatchWriteItem operation on AmazonDynamoDBv2.
*
* @return A Java Future object containing the response from the
* BatchWriteItem service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future batchWriteItemAsync(final BatchWriteItemRequest batchWriteItemRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public BatchWriteItemResult call() throws Exception {
return batchWriteItem(batchWriteItemRequest);
}
});
}
/**
*
* 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.
*
*
* NOTE: 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 .
*
*
* IMPORTANT: 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:
*
*
*
* -
* One or more tables specified in the BatchWriteItem request
* does not exist.
*
*
* -
* Primary key attributes specified on an item in the request do not
* match those in the corresponding table's primary key schema.
*
*
* -
* You try to perform multiple operations on the same item in the same
* BatchWriteItem request. For example, you cannot put and delete
* the same item in the same BatchWriteItem request.
*
*
* -
* There are more than 25 requests in the batch.
*
*
* -
* Any individual item in a batch exceeds 400 KB.
*
*
* -
* The total request size exceeds 16 MB.
*
*
*
*
*
* @param batchWriteItemRequest Container for the necessary parameters to
* execute the BatchWriteItem operation on AmazonDynamoDBv2.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* BatchWriteItem service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future batchWriteItemAsync(
final BatchWriteItemRequest batchWriteItemRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public BatchWriteItemResult call() throws Exception {
BatchWriteItemResult result;
try {
result = batchWriteItem(batchWriteItemRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(batchWriteItemRequest, result);
return result;
}
});
}
/**
*
* The DeleteTable operation deletes a table and all of its
* items. After a DeleteTable request, the specified table is in
* the DELETING state until DynamoDB completes the deletion.
* If the table is in the ACTIVE state, you can delete it.
* If a table is in CREATING or UPDATING
* states, then DynamoDB returns a ResourceInUseException . If the
* specified table does not exist, DynamoDB returns a
* ResourceNotFoundException . If table is already in the
* DELETING state, no error is returned.
*
*
* NOTE: DynamoDB might continue to accept data read and write
* operations, such as GetItem and PutItem, on a table in the DELETING
* state until the table deletion is complete.
*
*
* When you delete a table, any indexes on that table are also deleted.
*
*
* If you have DynamoDB Streams enabled on the table, then the
* corresponding stream on that table goes into the DISABLED
* state, and the stream is automatically deleted after 24 hours.
*
*
* Use the DescribeTable API to check the status of the table.
*
*
* @param deleteTableRequest Container for the necessary parameters to
* execute the DeleteTable operation on AmazonDynamoDBv2.
*
* @return A Java Future object containing the response from the
* DeleteTable service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteTableAsync(final DeleteTableRequest deleteTableRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DeleteTableResult call() throws Exception {
return deleteTable(deleteTableRequest);
}
});
}
/**
*
* The DeleteTable operation deletes a table and all of its
* items. After a DeleteTable request, the specified table is in
* the DELETING state until DynamoDB completes the deletion.
* If the table is in the ACTIVE state, you can delete it.
* If a table is in CREATING or UPDATING
* states, then DynamoDB returns a ResourceInUseException . If the
* specified table does not exist, DynamoDB returns a
* ResourceNotFoundException . If table is already in the
* DELETING state, no error is returned.
*
*
* NOTE: DynamoDB might continue to accept data read and write
* operations, such as GetItem and PutItem, on a table in the DELETING
* state until the table deletion is complete.
*
*
* When you delete a table, any indexes on that table are also deleted.
*
*
* If you have DynamoDB Streams enabled on the table, then the
* corresponding stream on that table goes into the DISABLED
* state, and the stream is automatically deleted after 24 hours.
*
*
* Use the DescribeTable API to check the status of the table.
*
*
* @param deleteTableRequest Container for the necessary parameters to
* execute the DeleteTable operation on AmazonDynamoDBv2.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteTable service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteTableAsync(
final DeleteTableRequest deleteTableRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DeleteTableResult call() throws Exception {
DeleteTableResult result;
try {
result = deleteTable(deleteTableRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteTableRequest, result);
return result;
}
});
}
/**
*
* 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.
*
*
* @param deleteItemRequest Container for the necessary parameters to
* execute the DeleteItem operation on AmazonDynamoDBv2.
*
* @return A Java Future object containing the response from the
* DeleteItem service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteItemAsync(final DeleteItemRequest deleteItemRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DeleteItemResult call() throws Exception {
return deleteItem(deleteItemRequest);
}
});
}
/**
*
* 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.
*
*
* @param deleteItemRequest Container for the necessary parameters to
* execute the DeleteItem operation on AmazonDynamoDBv2.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DeleteItem service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future deleteItemAsync(
final DeleteItemRequest deleteItemRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DeleteItemResult call() throws Exception {
DeleteItemResult result;
try {
result = deleteItem(deleteItemRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(deleteItemRequest, result);
return result;
}
});
}
/**
*
* Modifies the provisioned throughput settings, global secondary
* indexes, or DynamoDB Streams settings for a given table.
*
*
* You can only perform one of the following operations at once:
*
*
*
* -
* Modify the provisioned throughput settings of the table.
*
*
* -
* Enable or disable Streams on the table.
*
*
* -
* Remove a global secondary index from the table.
*
*
* -
* Create a new global secondary index on the table. Once the index
* begins backfilling, you can use UpdateTable to perform other
* operations.
*
*
*
*
*
* UpdateTable is an asynchronous operation; while it is
* executing, the table status changes from ACTIVE to
* UPDATING . While it is UPDATING , you cannot
* issue another UpdateTable request. When the table returns to
* the ACTIVE state, the UpdateTable operation is
* complete.
*
*
* @param updateTableRequest Container for the necessary parameters to
* execute the UpdateTable operation on AmazonDynamoDBv2.
*
* @return A Java Future object containing the response from the
* UpdateTable service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future updateTableAsync(final UpdateTableRequest updateTableRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public UpdateTableResult call() throws Exception {
return updateTable(updateTableRequest);
}
});
}
/**
*
* Modifies the provisioned throughput settings, global secondary
* indexes, or DynamoDB Streams settings for a given table.
*
*
* You can only perform one of the following operations at once:
*
*
*
* -
* Modify the provisioned throughput settings of the table.
*
*
* -
* Enable or disable Streams on the table.
*
*
* -
* Remove a global secondary index from the table.
*
*
* -
* Create a new global secondary index on the table. Once the index
* begins backfilling, you can use UpdateTable to perform other
* operations.
*
*
*
*
*
* UpdateTable is an asynchronous operation; while it is
* executing, the table status changes from ACTIVE to
* UPDATING . While it is UPDATING , you cannot
* issue another UpdateTable request. When the table returns to
* the ACTIVE state, the UpdateTable operation is
* complete.
*
*
* @param updateTableRequest Container for the necessary parameters to
* execute the UpdateTable operation on AmazonDynamoDBv2.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* UpdateTable service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future updateTableAsync(
final UpdateTableRequest updateTableRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public UpdateTableResult call() throws Exception {
UpdateTableResult result;
try {
result = updateTable(updateTableRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(updateTableRequest, result);
return result;
}
});
}
/**
*
* 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.
*
*
* @param updateItemRequest Container for the necessary parameters to
* execute the UpdateItem operation on AmazonDynamoDBv2.
*
* @return A Java Future object containing the response from the
* UpdateItem service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future updateItemAsync(final UpdateItemRequest updateItemRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public UpdateItemResult call() throws Exception {
return updateItem(updateItemRequest);
}
});
}
/**
*
* 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.
*
*
* @param updateItemRequest Container for the necessary parameters to
* execute the UpdateItem operation on AmazonDynamoDBv2.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* UpdateItem service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future updateItemAsync(
final UpdateItemRequest updateItemRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public UpdateItemResult call() throws Exception {
UpdateItemResult result;
try {
result = updateItem(updateItemRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(updateItemRequest, result);
return result;
}
});
}
/**
*
* 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.
*
*
* NOTE: 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.
*
*
* @param describeTableRequest Container for the necessary parameters to
* execute the DescribeTable operation on AmazonDynamoDBv2.
*
* @return A Java Future object containing the response from the
* DescribeTable service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future describeTableAsync(final DescribeTableRequest describeTableRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DescribeTableResult call() throws Exception {
return describeTable(describeTableRequest);
}
});
}
/**
*
* 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.
*
*
* NOTE: 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.
*
*
* @param describeTableRequest Container for the necessary parameters to
* execute the DescribeTable operation on AmazonDynamoDBv2.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the
* DescribeTable service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future describeTableAsync(
final DescribeTableRequest describeTableRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public DescribeTableResult call() throws Exception {
DescribeTableResult result;
try {
result = describeTable(describeTableRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(describeTableRequest, result);
return result;
}
});
}
/**
*
* 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 the results exceed 1 MB, or if you have used the
* Limit parameter.
*
*
* 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 true and
* obtain a strongly consistent result. Global secondary indexes support
* eventually consistent reads only, so do not specify
* ConsistentRead when querying a global secondary index.
*
*
* @param queryRequest Container for the necessary parameters to execute
* the Query operation on AmazonDynamoDBv2.
*
* @return A Java Future object containing the response from the Query
* service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future queryAsync(final QueryRequest queryRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public QueryResult call() throws Exception {
return query(queryRequest);
}
});
}
/**
*
* 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 the results exceed 1 MB, or if you have used the
* Limit parameter.
*
*
* 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 true and
* obtain a strongly consistent result. Global secondary indexes support
* eventually consistent reads only, so do not specify
* ConsistentRead when querying a global secondary index.
*
*
* @param queryRequest Container for the necessary parameters to execute
* the Query operation on AmazonDynamoDBv2.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the Query
* service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future queryAsync(
final QueryRequest queryRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public QueryResult call() throws Exception {
QueryResult result;
try {
result = query(queryRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(queryRequest, result);
return result;
}
});
}
/**
*
* 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.
*
*
* NOTE: To prevent a new item from replacing an existing item,
* use a conditional expression that contains the attribute_not_exists
* function with the name of the attribute being used as the partition
* key for the table. Since every record must contain that attribute,
* the attribute_not_exists function will only succeed if no matching
* item exists.
*
*
* For more information about using this API, see
* Working with Items
* in the Amazon DynamoDB Developer Guide .
*
*
* @param putItemRequest Container for the necessary parameters to
* execute the PutItem operation on AmazonDynamoDBv2.
*
* @return A Java Future object containing the response from the PutItem
* service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future putItemAsync(final PutItemRequest putItemRequest)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public PutItemResult call() throws Exception {
return putItem(putItemRequest);
}
});
}
/**
*
* 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.
*
*
* NOTE: To prevent a new item from replacing an existing item,
* use a conditional expression that contains the attribute_not_exists
* function with the name of the attribute being used as the partition
* key for the table. Since every record must contain that attribute,
* the attribute_not_exists function will only succeed if no matching
* item exists.
*
*
* For more information about using this API, see
* Working with Items
* in the Amazon DynamoDB Developer Guide .
*
*
* @param putItemRequest Container for the necessary parameters to
* execute the PutItem operation on AmazonDynamoDBv2.
* @param asyncHandler Asynchronous callback handler for events in the
* life-cycle of the request. Users could provide the implementation of
* the four callback methods in this interface to process the operation
* result or handle the exception.
*
* @return A Java Future object containing the response from the PutItem
* service method, as returned by AmazonDynamoDBv2.
*
*
* @throws AmazonClientException
* If any internal errors are encountered inside the client while
* attempting to make the request or handle the response. For example
* if a network connection is not available.
* @throws AmazonServiceException
* If an error response is returned by AmazonDynamoDBv2 indicating
* either a problem with the data in the request, or a server side issue.
*/
public Future putItemAsync(
final PutItemRequest putItemRequest,
final AsyncHandler asyncHandler)
throws AmazonServiceException, AmazonClientException {
return executorService.submit(new Callable() {
public PutItemResult call() throws Exception {
PutItemResult result;
try {
result = putItem(putItemRequest);
} catch (Exception ex) {
asyncHandler.onError(ex);
throw ex;
}
asyncHandler.onSuccess(putItemRequest, result);
return result;
}
});
}
}