com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-osgi Show documentation
/*
* Copyright 2011-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 org.w3c.dom.*;
import java.net.*;
import java.util.*;
import java.util.Map.Entry;
import org.apache.commons.logging.*;
import com.amazonaws.*;
import com.amazonaws.auth.*;
import com.amazonaws.handlers.*;
import com.amazonaws.http.*;
import com.amazonaws.internal.*;
import com.amazonaws.internal.auth.*;
import com.amazonaws.metrics.*;
import com.amazonaws.regions.*;
import com.amazonaws.transform.*;
import com.amazonaws.util.*;
import com.amazonaws.protocol.json.*;
import com.amazonaws.util.AWSRequestMetrics.Field;
import com.amazonaws.annotation.ThreadSafe;
import com.amazonaws.client.AwsSyncClientParams;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.dynamodbv2.model.*;
import com.amazonaws.services.dynamodbv2.model.transform.*;
/**
* Client for accessing DynamoDB. All service calls made using this client are
* blocking, and will not return until the service call completes.
*
* 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.
*
*/
@ThreadSafe
public class AmazonDynamoDBClient extends AmazonWebServiceClient implements
AmazonDynamoDB {
// register the service specific set of predefined metrics
static {
AwsSdkMetrics
.addAll(Arrays
.asList(com.amazonaws.services.dynamodbv2.metrics.DynamoDBRequestMetric
.values()));
}
/** Provider for AWS credentials. */
private final AWSCredentialsProvider awsCredentialsProvider;
private static final Log log = LogFactory.getLog(AmazonDynamoDB.class);
/** Default signing name for the service. */
private static final String DEFAULT_SIGNING_NAME = "dynamodb";
/**
* Client configuration factory providing ClientConfigurations tailored to
* this client
*/
protected static final com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientConfigurationFactory configFactory = new com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientConfigurationFactory();
private final SdkJsonProtocolFactory protocolFactory = new SdkJsonProtocolFactory(
new JsonClientMetadata()
.withProtocolVersion("1.0")
.withSupportsCbor(false)
.addErrorMetadata(
new JsonErrorShapeMetadata()
.withErrorCode(
"ItemCollectionSizeLimitExceededException")
.withModeledClass(
com.amazonaws.services.dynamodbv2.model.ItemCollectionSizeLimitExceededException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata()
.withErrorCode("ResourceInUseException")
.withModeledClass(
com.amazonaws.services.dynamodbv2.model.ResourceInUseException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata()
.withErrorCode("ResourceNotFoundException")
.withModeledClass(
com.amazonaws.services.dynamodbv2.model.ResourceNotFoundException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata()
.withErrorCode(
"ProvisionedThroughputExceededException")
.withModeledClass(
com.amazonaws.services.dynamodbv2.model.ProvisionedThroughputExceededException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata()
.withErrorCode(
"ConditionalCheckFailedException")
.withModeledClass(
com.amazonaws.services.dynamodbv2.model.ConditionalCheckFailedException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata()
.withErrorCode("InternalServerError")
.withModeledClass(
com.amazonaws.services.dynamodbv2.model.InternalServerErrorException.class))
.addErrorMetadata(
new JsonErrorShapeMetadata()
.withErrorCode("LimitExceededException")
.withModeledClass(
com.amazonaws.services.dynamodbv2.model.LimitExceededException.class))
.withBaseServiceExceptionClass(
com.amazonaws.services.dynamodbv2.model.AmazonDynamoDBException.class));
/**
* Constructs a new client to invoke service methods on DynamoDB. 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
*/
public AmazonDynamoDBClient() {
this(new DefaultAWSCredentialsProviderChain(), configFactory
.getConfig());
}
/**
* Constructs a new client to invoke service methods on DynamoDB. 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 DynamoDB (ex: proxy settings, retry counts, etc.).
*
* @see DefaultAWSCredentialsProviderChain
*/
public AmazonDynamoDBClient(ClientConfiguration clientConfiguration) {
this(new DefaultAWSCredentialsProviderChain(), clientConfiguration);
}
/**
* Constructs a new client to invoke service methods on DynamoDB using the
* specified AWS account credentials.
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when
* authenticating with AWS services.
*/
public AmazonDynamoDBClient(AWSCredentials awsCredentials) {
this(awsCredentials, configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on DynamoDB using the
* specified AWS account credentials and client configuration options.
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when
* authenticating with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client
* connects to DynamoDB (ex: proxy settings, retry counts, etc.).
*/
public AmazonDynamoDBClient(AWSCredentials awsCredentials,
ClientConfiguration clientConfiguration) {
super(clientConfiguration);
this.awsCredentialsProvider = new StaticCredentialsProvider(
awsCredentials);
init();
}
/**
* Constructs a new client to invoke service methods on DynamoDB using the
* specified AWS account credentials provider.
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to
* authenticate requests with AWS services.
*/
public AmazonDynamoDBClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on DynamoDB using the
* specified AWS account credentials provider and client configuration
* options.
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to
* authenticate requests with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client
* connects to DynamoDB (ex: proxy settings, retry counts, etc.).
*/
public AmazonDynamoDBClient(AWSCredentialsProvider awsCredentialsProvider,
ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, null);
}
/**
* Constructs a new client to invoke service methods on DynamoDB using the
* specified AWS account credentials provider, client configuration options,
* and request metric collector.
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to
* authenticate requests with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client
* connects to DynamoDB (ex: proxy settings, retry counts, etc.).
* @param requestMetricCollector
* optional request metric collector
*/
public AmazonDynamoDBClient(AWSCredentialsProvider awsCredentialsProvider,
ClientConfiguration clientConfiguration,
RequestMetricCollector requestMetricCollector) {
super(clientConfiguration, requestMetricCollector);
this.awsCredentialsProvider = awsCredentialsProvider;
init();
}
/**
* Constructs a new client to invoke service methods on DynamoDB using the
* specified parameters.
*
*
* All service calls made using this new client object are blocking, and
* will not return until the service call completes.
*
* @param clientParams
* Object providing client parameters.
*/
AmazonDynamoDBClient(AwsSyncClientParams clientParams) {
super(clientParams);
this.awsCredentialsProvider = clientParams.getCredentialsProvider();
init();
}
private void init() {
setServiceNameIntern(DEFAULT_SIGNING_NAME);
setEndpointPrefix(ENDPOINT_PREFIX);
// calling this.setEndPoint(...) will also modify the signer accordingly
setEndpoint("https://dynamodb.us-east-1.amazonaws.com");
HandlerChainFactory chainFactory = new HandlerChainFactory();
requestHandler2s
.addAll(chainFactory
.newRequestHandlerChain("/com/amazonaws/services/dynamodbv2/request.handlers"));
requestHandler2s
.addAll(chainFactory
.newRequestHandler2Chain("/com/amazonaws/services/dynamodbv2/request.handler2s"));
}
/**
*
* 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 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 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.
*
*
* @param batchGetItemRequest
* Represents the input of a BatchGetItem operation.
* @return Result of the BatchGetItem operation returned by the service.
* @throws ProvisionedThroughputExceededException
* Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your
* request is eventually successful, unless your retry queue is too
* large to finish. Reduce the frequency of requests and use
* exponential backoff. For more information, go to Error Retries and Exponential Backoff in the Amazon
* DynamoDB Developer Guide.
* @throws ResourceNotFoundException
* The operation tried to access a nonexistent table or index. The
* resource might not be specified correctly, or its status might
* not be ACTIVE.
* @throws InternalServerErrorException
* An error occurred on the server side.
* @sample AmazonDynamoDB.BatchGetItem
*/
@Override
public BatchGetItemResult batchGetItem(
BatchGetItemRequest batchGetItemRequest) {
ExecutionContext executionContext = createExecutionContext(batchGetItemRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new BatchGetItemRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(batchGetItemRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true)
.withHasStreamingSuccessResponse(false),
new BatchGetItemResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public BatchGetItemResult batchGetItem(
java.util.Map requestItems,
String returnConsumedCapacity) {
return batchGetItem(new BatchGetItemRequest().withRequestItems(
requestItems)
.withReturnConsumedCapacity(returnConsumedCapacity));
}
@Override
public BatchGetItemResult batchGetItem(
java.util.Map requestItems) {
return batchGetItem(new BatchGetItemRequest()
.withRequestItems(requestItems));
}
/**
*
* 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:
*
*
* -
*
* 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
* Represents the input of a BatchWriteItem operation.
* @return Result of the BatchWriteItem operation returned by the service.
* @throws ProvisionedThroughputExceededException
* Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your
* request is eventually successful, unless your retry queue is too
* large to finish. Reduce the frequency of requests and use
* exponential backoff. For more information, go to Error Retries and Exponential Backoff in the Amazon
* DynamoDB Developer Guide.
* @throws ResourceNotFoundException
* The operation tried to access a nonexistent table or index. The
* resource might not be specified correctly, or its status might
* not be ACTIVE.
* @throws ItemCollectionSizeLimitExceededException
* An item collection is too large. This exception is only returned
* for tables that have one or more local secondary indexes.
* @throws InternalServerErrorException
* An error occurred on the server side.
* @sample AmazonDynamoDB.BatchWriteItem
*/
@Override
public BatchWriteItemResult batchWriteItem(
BatchWriteItemRequest batchWriteItemRequest) {
ExecutionContext executionContext = createExecutionContext(batchWriteItemRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new BatchWriteItemRequestMarshaller(protocolFactory)
.marshall(super
.beforeMarshalling(batchWriteItemRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true)
.withHasStreamingSuccessResponse(false),
new BatchWriteItemResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public BatchWriteItemResult batchWriteItem(
java.util.Map> requestItems) {
return batchWriteItem(new BatchWriteItemRequest()
.withRequestItems(requestItems));
}
/**
*
* 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
* Represents the input of a CreateTable operation.
* @return Result of the CreateTable operation returned by the service.
* @throws ResourceInUseException
* The operation conflicts with the resource's availability. For
* example, you attempted to recreate an existing table, or tried to
* delete a table currently in the CREATING state.
* @throws LimitExceededException
* The number of concurrent table requests (cumulative number of
* tables in the CREATING, DELETING or
* UPDATING state) exceeds the maximum allowed of
* 10.
*
* Also, for tables with secondary indexes, only one of those tables
* can be in the CREATING state at any point in time.
* Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is
* 250.
* @throws InternalServerErrorException
* An error occurred on the server side.
* @sample AmazonDynamoDB.CreateTable
*/
@Override
public CreateTableResult createTable(CreateTableRequest createTableRequest) {
ExecutionContext executionContext = createExecutionContext(createTableRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateTableRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(createTableRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true)
.withHasStreamingSuccessResponse(false),
new CreateTableResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public CreateTableResult createTable(
java.util.List attributeDefinitions,
String tableName, java.util.List keySchema,
ProvisionedThroughput provisionedThroughput) {
return createTable(new CreateTableRequest()
.withAttributeDefinitions(attributeDefinitions)
.withTableName(tableName).withKeySchema(keySchema)
.withProvisionedThroughput(provisionedThroughput));
}
/**
*
* 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
* Represents the input of a DeleteItem operation.
* @return Result of the DeleteItem operation returned by the service.
* @throws ConditionalCheckFailedException
* A condition specified in the operation could not be evaluated.
* @throws ProvisionedThroughputExceededException
* Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your
* request is eventually successful, unless your retry queue is too
* large to finish. Reduce the frequency of requests and use
* exponential backoff. For more information, go to Error Retries and Exponential Backoff in the Amazon
* DynamoDB Developer Guide.
* @throws ResourceNotFoundException
* The operation tried to access a nonexistent table or index. The
* resource might not be specified correctly, or its status might
* not be ACTIVE.
* @throws ItemCollectionSizeLimitExceededException
* An item collection is too large. This exception is only returned
* for tables that have one or more local secondary indexes.
* @throws InternalServerErrorException
* An error occurred on the server side.
* @sample AmazonDynamoDB.DeleteItem
*/
@Override
public DeleteItemResult deleteItem(DeleteItemRequest deleteItemRequest) {
ExecutionContext executionContext = createExecutionContext(deleteItemRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteItemRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(deleteItemRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true)
.withHasStreamingSuccessResponse(false),
new DeleteItemResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DeleteItemResult deleteItem(String tableName,
java.util.Map key) {
return deleteItem(new DeleteItemRequest().withTableName(tableName)
.withKey(key));
}
@Override
public DeleteItemResult deleteItem(String tableName,
java.util.Map key, String returnValues) {
return deleteItem(new DeleteItemRequest().withTableName(tableName)
.withKey(key).withReturnValues(returnValues));
}
/**
*
* 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.
*
*
*
* 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
* Represents the input of a DeleteTable operation.
* @return Result of the DeleteTable operation returned by the service.
* @throws ResourceInUseException
* The operation conflicts with the resource's availability. For
* example, you attempted to recreate an existing table, or tried to
* delete a table currently in the CREATING state.
* @throws ResourceNotFoundException
* The operation tried to access a nonexistent table or index. The
* resource might not be specified correctly, or its status might
* not be ACTIVE.
* @throws LimitExceededException
* The number of concurrent table requests (cumulative number of
* tables in the CREATING, DELETING or
* UPDATING state) exceeds the maximum allowed of
* 10.
*
* Also, for tables with secondary indexes, only one of those tables
* can be in the CREATING state at any point in time.
* Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is
* 250.
* @throws InternalServerErrorException
* An error occurred on the server side.
* @sample AmazonDynamoDB.DeleteTable
*/
@Override
public DeleteTableResult deleteTable(DeleteTableRequest deleteTableRequest) {
ExecutionContext executionContext = createExecutionContext(deleteTableRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteTableRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(deleteTableRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true)
.withHasStreamingSuccessResponse(false),
new DeleteTableResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DeleteTableResult deleteTable(String tableName) {
return deleteTable(new DeleteTableRequest().withTableName(tableName));
}
/**
*
* 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.
*
*
*
* 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
* Represents the input of a DescribeLimits operation. Has no
* content.
* @return Result of the DescribeLimits operation returned by the service.
* @throws InternalServerErrorException
* An error occurred on the server side.
* @sample AmazonDynamoDB.DescribeLimits
*/
@Override
public DescribeLimitsResult describeLimits(
DescribeLimitsRequest describeLimitsRequest) {
ExecutionContext executionContext = createExecutionContext(describeLimitsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeLimitsRequestMarshaller(protocolFactory)
.marshall(super
.beforeMarshalling(describeLimitsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true)
.withHasStreamingSuccessResponse(false),
new DescribeLimitsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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.
*
*
*
* @param describeTableRequest
* Represents the input of a DescribeTable operation.
* @return Result of the DescribeTable operation returned by the service.
* @throws ResourceNotFoundException
* The operation tried to access a nonexistent table or index. The
* resource might not be specified correctly, or its status might
* not be ACTIVE.
* @throws InternalServerErrorException
* An error occurred on the server side.
* @sample AmazonDynamoDB.DescribeTable
*/
@Override
public DescribeTableResult describeTable(
DescribeTableRequest describeTableRequest) {
ExecutionContext executionContext = createExecutionContext(describeTableRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeTableRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(describeTableRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true)
.withHasStreamingSuccessResponse(false),
new DescribeTableResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public DescribeTableResult describeTable(String tableName) {
return describeTable(new DescribeTableRequest()
.withTableName(tableName));
}
/**
*
* 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
* Represents the input of a GetItem operation.
* @return Result of the GetItem operation returned by the service.
* @throws ProvisionedThroughputExceededException
* Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your
* request is eventually successful, unless your retry queue is too
* large to finish. Reduce the frequency of requests and use
* exponential backoff. For more information, go to Error Retries and Exponential Backoff in the Amazon
* DynamoDB Developer Guide.
* @throws ResourceNotFoundException
* The operation tried to access a nonexistent table or index. The
* resource might not be specified correctly, or its status might
* not be ACTIVE.
* @throws InternalServerErrorException
* An error occurred on the server side.
* @sample AmazonDynamoDB.GetItem
*/
@Override
public GetItemResult getItem(GetItemRequest getItemRequest) {
ExecutionContext executionContext = createExecutionContext(getItemRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetItemRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(getItemRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true)
.withHasStreamingSuccessResponse(false),
new GetItemResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public GetItemResult getItem(String tableName,
java.util.Map key) {
return getItem(new GetItemRequest().withTableName(tableName).withKey(
key));
}
@Override
public GetItemResult getItem(String tableName,
java.util.Map key, Boolean consistentRead) {
return getItem(new GetItemRequest().withTableName(tableName)
.withKey(key).withConsistentRead(consistentRead));
}
/**
*
* 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
* Represents the input of a ListTables operation.
* @return Result of the ListTables operation returned by the service.
* @throws InternalServerErrorException
* An error occurred on the server side.
* @sample AmazonDynamoDB.ListTables
*/
@Override
public ListTablesResult listTables(ListTablesRequest listTablesRequest) {
ExecutionContext executionContext = createExecutionContext(listTablesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListTablesRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(listTablesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true)
.withHasStreamingSuccessResponse(false),
new ListTablesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public ListTablesResult listTables() {
return listTables(new ListTablesRequest());
}
@Override
public ListTablesResult listTables(String exclusiveStartTableName) {
return listTables(new ListTablesRequest()
.withExclusiveStartTableName(exclusiveStartTableName));
}
@Override
public ListTablesResult listTables(String exclusiveStartTableName,
Integer limit) {
return listTables(new ListTablesRequest().withExclusiveStartTableName(
exclusiveStartTableName).withLimit(limit));
}
@Override
public ListTablesResult listTables(Integer limit) {
return listTables(new ListTablesRequest().withLimit(limit));
}
/**
*
* 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 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
* Represents the input of a PutItem operation.
* @return Result of the PutItem operation returned by the service.
* @throws ConditionalCheckFailedException
* A condition specified in the operation could not be evaluated.
* @throws ProvisionedThroughputExceededException
* Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your
* request is eventually successful, unless your retry queue is too
* large to finish. Reduce the frequency of requests and use
* exponential backoff. For more information, go to Error Retries and Exponential Backoff in the Amazon
* DynamoDB Developer Guide.
* @throws ResourceNotFoundException
* The operation tried to access a nonexistent table or index. The
* resource might not be specified correctly, or its status might
* not be ACTIVE.
* @throws ItemCollectionSizeLimitExceededException
* An item collection is too large. This exception is only returned
* for tables that have one or more local secondary indexes.
* @throws InternalServerErrorException
* An error occurred on the server side.
* @sample AmazonDynamoDB.PutItem
*/
@Override
public PutItemResult putItem(PutItemRequest putItemRequest) {
ExecutionContext executionContext = createExecutionContext(putItemRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new PutItemRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(putItemRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true)
.withHasStreamingSuccessResponse(false),
new PutItemResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public PutItemResult putItem(String tableName,
java.util.Map item) {
return putItem(new PutItemRequest().withTableName(tableName).withItem(
item));
}
@Override
public PutItemResult putItem(String tableName,
java.util.Map item, String returnValues) {
return putItem(new PutItemRequest().withTableName(tableName)
.withItem(item).withReturnValues(returnValues));
}
/**
*
* 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 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
* Represents the input of a Query operation.
* @return Result of the Query operation returned by the service.
* @throws ProvisionedThroughputExceededException
* Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your
* request is eventually successful, unless your retry queue is too
* large to finish. Reduce the frequency of requests and use
* exponential backoff. For more information, go to Error Retries and Exponential Backoff in the Amazon
* DynamoDB Developer Guide.
* @throws ResourceNotFoundException
* The operation tried to access a nonexistent table or index. The
* resource might not be specified correctly, or its status might
* not be ACTIVE.
* @throws InternalServerErrorException
* An error occurred on the server side.
* @sample AmazonDynamoDB.Query
*/
@Override
public QueryResult query(QueryRequest queryRequest) {
ExecutionContext executionContext = createExecutionContext(queryRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new QueryRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(queryRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true)
.withHasStreamingSuccessResponse(false),
new QueryResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* 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
* Represents the input of a Scan operation.
* @return Result of the Scan operation returned by the service.
* @throws ProvisionedThroughputExceededException
* Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your
* request is eventually successful, unless your retry queue is too
* large to finish. Reduce the frequency of requests and use
* exponential backoff. For more information, go to Error Retries and Exponential Backoff in the Amazon
* DynamoDB Developer Guide.
* @throws ResourceNotFoundException
* The operation tried to access a nonexistent table or index. The
* resource might not be specified correctly, or its status might
* not be ACTIVE.
* @throws InternalServerErrorException
* An error occurred on the server side.
* @sample AmazonDynamoDB.Scan
*/
@Override
public ScanResult scan(ScanRequest scanRequest) {
ExecutionContext executionContext = createExecutionContext(scanRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ScanRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(scanRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true)
.withHasStreamingSuccessResponse(false),
new ScanResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public ScanResult scan(String tableName,
java.util.List attributesToGet) {
return scan(new ScanRequest().withTableName(tableName)
.withAttributesToGet(attributesToGet));
}
@Override
public ScanResult scan(String tableName,
java.util.Map scanFilter) {
return scan(new ScanRequest().withTableName(tableName).withScanFilter(
scanFilter));
}
@Override
public ScanResult scan(String tableName,
java.util.List attributesToGet,
java.util.Map scanFilter) {
return scan(new ScanRequest().withTableName(tableName)
.withAttributesToGet(attributesToGet)
.withScanFilter(scanFilter));
}
/**
*
* 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
* Represents the input of an UpdateItem operation.
* @return Result of the UpdateItem operation returned by the service.
* @throws ConditionalCheckFailedException
* A condition specified in the operation could not be evaluated.
* @throws ProvisionedThroughputExceededException
* Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your
* request is eventually successful, unless your retry queue is too
* large to finish. Reduce the frequency of requests and use
* exponential backoff. For more information, go to Error Retries and Exponential Backoff in the Amazon
* DynamoDB Developer Guide.
* @throws ResourceNotFoundException
* The operation tried to access a nonexistent table or index. The
* resource might not be specified correctly, or its status might
* not be ACTIVE.
* @throws ItemCollectionSizeLimitExceededException
* An item collection is too large. This exception is only returned
* for tables that have one or more local secondary indexes.
* @throws InternalServerErrorException
* An error occurred on the server side.
* @sample AmazonDynamoDB.UpdateItem
*/
@Override
public UpdateItemResult updateItem(UpdateItemRequest updateItemRequest) {
ExecutionContext executionContext = createExecutionContext(updateItemRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateItemRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(updateItemRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true)
.withHasStreamingSuccessResponse(false),
new UpdateItemResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public UpdateItemResult updateItem(String tableName,
java.util.Map key,
java.util.Map attributeUpdates) {
return updateItem(new UpdateItemRequest().withTableName(tableName)
.withKey(key).withAttributeUpdates(attributeUpdates));
}
@Override
public UpdateItemResult updateItem(String tableName,
java.util.Map key,
java.util.Map attributeUpdates,
String returnValues) {
return updateItem(new UpdateItemRequest().withTableName(tableName)
.withKey(key).withAttributeUpdates(attributeUpdates)
.withReturnValues(returnValues));
}
/**
*
* 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
* Represents the input of an UpdateTable operation.
* @return Result of the UpdateTable operation returned by the service.
* @throws ResourceInUseException
* The operation conflicts with the resource's availability. For
* example, you attempted to recreate an existing table, or tried to
* delete a table currently in the CREATING state.
* @throws ResourceNotFoundException
* The operation tried to access a nonexistent table or index. The
* resource might not be specified correctly, or its status might
* not be ACTIVE.
* @throws LimitExceededException
* The number of concurrent table requests (cumulative number of
* tables in the CREATING, DELETING or
* UPDATING state) exceeds the maximum allowed of
* 10.
*
* Also, for tables with secondary indexes, only one of those tables
* can be in the CREATING state at any point in time.
* Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is
* 250.
* @throws InternalServerErrorException
* An error occurred on the server side.
* @sample AmazonDynamoDB.UpdateTable
*/
@Override
public UpdateTableResult updateTable(UpdateTableRequest updateTableRequest) {
ExecutionContext executionContext = createExecutionContext(updateTableRequest);
AWSRequestMetrics awsRequestMetrics = executionContext
.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateTableRequestMarshaller(protocolFactory)
.marshall(super.beforeMarshalling(updateTableRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true)
.withHasStreamingSuccessResponse(false),
new UpdateTableResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public UpdateTableResult updateTable(String tableName,
ProvisionedThroughput provisionedThroughput) {
return updateTable(new UpdateTableRequest().withTableName(tableName)
.withProvisionedThroughput(provisionedThroughput));
}
/**
* Returns additional metadata for a previously executed successful,
* request, typically used for debugging issues where a service isn't acting
* as expected. This data isn't considered part of the result data returned
* by an operation, so it's available through this separate, diagnostic
* interface.
*
* Response metadata is only cached for a limited period of time, so if you
* need to access this extra diagnostic information for an executed request,
* you should use this method to retrieve it as soon as possible after
* executing the request.
*
* @param request
* The originally executed request
*
* @return The response metadata for the specified request, or null if none
* is available.
*/
public ResponseMetadata getCachedResponseMetadata(
AmazonWebServiceRequest request) {
return client.getResponseMetadataForRequest(request);
}
@Override
protected final boolean calculateCRC32FromCompressedData() {
return true;
}
/**
* Normal invoke with authentication. Credentials are required and may be
* overriden at the request level.
**/
private Response invoke(
Request request,
HttpResponseHandler> responseHandler,
ExecutionContext executionContext) {
executionContext.setCredentialsProvider(CredentialUtils
.getCredentialsProvider(request.getOriginalRequest(),
awsCredentialsProvider));
return doInvoke(request, responseHandler, executionContext);
}
/**
* Invoke with no authentication. Credentials are not required and any
* credentials set on the client or request will be ignored for this
* operation.
**/
private Response anonymousInvoke(
Request request,
HttpResponseHandler> responseHandler,
ExecutionContext executionContext) {
return doInvoke(request, responseHandler, executionContext);
}
/**
* Invoke the request using the http client. Assumes credentials (or lack
* thereof) have been configured in the ExecutionContext beforehand.
**/
private Response doInvoke(
Request request,
HttpResponseHandler> responseHandler,
ExecutionContext executionContext) {
request.setEndpoint(endpoint);
request.setTimeOffset(timeOffset);
HttpResponseHandler errorResponseHandler = protocolFactory
.createErrorResponseHandler(new JsonErrorResponseMetadata());
return client.execute(request, responseHandler, errorResponseHandler,
executionContext);
}
}