*
* Amazon DynamoDB is a fully managed NoSQL database service that provides fast * and predictable performance with seamless scalability. DynamoDB lets you * offload the administrative burdens of operating and scaling a distributed * database, so that you don't have to worry about hardware provisioning, setup * and configuration, replication, software patching, or cluster scaling. *
** With DynamoDB, you can create database tables that can store and retrieve any * amount of data, and serve any level of request traffic. You can scale up or * scale down your tables' throughput capacity without downtime or performance * degradation, and use the AWS Management Console to monitor resource * utilization and performance metrics. *
** DynamoDB automatically spreads the data and traffic for your tables over a * sufficient number of servers to handle your throughput and storage * requirements, while maintaining consistent and fast performance. All of your * data is stored on solid state disks (SSDs) and automatically replicated * across multiple Availability Zones in an AWS region, providing built-in high * availability and data durability. *
*/ public class AmazonDynamoDBClient extends AmazonWebServiceClient implements AmazonDynamoDB { /** Provider for AWS credentials. */ private AWSCredentialsProvider awsCredentialsProvider; /** * List of exception unmarshallers for all Amazon DynamoDB exceptions. */ protected List* All service calls made using this new client object are blocking, and * will not return until the service call completes. * * @see DefaultAWSCredentialsProviderChain */ @Deprecated public AmazonDynamoDBClient() { this(new DefaultAWSCredentialsProviderChain(), new ClientConfiguration()); } /** * Constructs a new client to invoke service methods on AmazonDynamoDB. A * credentials provider chain will be used that searches for credentials in * this order: *
* 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 AmazonDynamoDB (ex: proxy * settings, retry counts, etc.). * @see DefaultAWSCredentialsProviderChain */ @Deprecated public AmazonDynamoDBClient(ClientConfiguration clientConfiguration) { this(new DefaultAWSCredentialsProviderChain(), clientConfiguration); } /** * Constructs a new client to invoke service methods on AmazonDynamoDB using * the specified AWS account credentials. *
* The client requests are authenticated using the {@link AWSCredentials} * provided in this constructor. Static AWSCredentials can be passed for * quick testing. However, it is strongly recommended to use Amazon Cognito * vended temporary credentials for use in production. This can be achieved * by using {@link AWSMobileClient}. Please see * https://aws-amplify.github.io/docs/android/authentication for * instructions on how to enable {@link AWSMobileClient}. * *
* AWSMobileClient.getInstance().initialize(getApplicationContext(), new Callback<UserStateDetails>() {
* @Override
* public void onResult(final UserStateDetails details) {
* AmazonDynamoDB client = new AmazonDynamoDBClient(AWSMobileClient.getInstance());
* }
*
* @Override
* public void onError(final Exception e) {
* e.printStackTrace();
* }
* });
*
* * 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, new ClientConfiguration()); } /** * Constructs a new client to invoke service methods on AmazonDynamoDB using * the specified AWS account credentials and client configuration options. *
* The client requests are authenticated using the {@link AWSCredentials} * provided in this constructor. Static AWSCredentials can be passed for * quick testing. However, it is strongly recommended to use Amazon Cognito * vended temporary credentials for use in production. This can be achieved * by using {@link AWSMobileClient}. Please see * https://aws-amplify.github.io/docs/android/authentication for * instructions on how to enable {@link AWSMobileClient}. * *
* AWSMobileClient.getInstance().initialize(getApplicationContext(), new Callback<UserStateDetails>() {
* @Override
* public void onResult(final UserStateDetails details) {
* AmazonDynamoDB client = new AmazonDynamoDBClient(AWSMobileClient.getInstance());
* }
*
* @Override
* public void onError(final Exception e) {
* e.printStackTrace();
* }
* });
*
* * 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 AmazonDynamoDB (ex: proxy * settings, retry counts, etc.). */ public AmazonDynamoDBClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration) { this(new StaticCredentialsProvider(awsCredentials), clientConfiguration); } /** * Constructs a new client to invoke service methods on AmazonDynamoDB using * the specified AWS account credentials provider. *
* The client requests are authenticated using the {@link AWSCredentials} * provided in this constructor. Static AWSCredentials can be passed for * quick testing. However, it is strongly recommended to use Amazon Cognito * vended temporary credentials for use in production. This can be achieved * by using {@link AWSMobileClient}. Please see * https://aws-amplify.github.io/docs/android/authentication for * instructions on how to enable {@link AWSMobileClient}. * *
* AWSMobileClient.getInstance().initialize(getApplicationContext(), new Callback<UserStateDetails>() {
* @Override
* public void onResult(final UserStateDetails details) {
* AmazonDynamoDB client = new AmazonDynamoDBClient(AWSMobileClient.getInstance());
* }
*
* @Override
* public void onError(final Exception e) {
* e.printStackTrace();
* }
* });
*
* * 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, new ClientConfiguration()); } /** * Constructs a new client to invoke service methods on AmazonDynamoDB using * the specified AWS account credentials provider and client configuration * options. *
* The client requests are authenticated using the {@link AWSCredentials} * provided in this constructor. Static AWSCredentials can be passed for * quick testing. However, it is strongly recommended to use Amazon Cognito * vended temporary credentials for use in production. This can be achieved * by using {@link AWSMobileClient}. Please see * https://aws-amplify.github.io/docs/android/authentication for * instructions on how to enable {@link AWSMobileClient}. * *
* AWSMobileClient.getInstance().initialize(getApplicationContext(), new Callback<UserStateDetails>() {
* @Override
* public void onResult(final UserStateDetails details) {
* AmazonDynamoDB client = new AmazonDynamoDBClient(AWSMobileClient.getInstance());
* }
*
* @Override
* public void onError(final Exception e) {
* e.printStackTrace();
* }
* });
*
* * 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 AmazonDynamoDB (ex: proxy * settings, retry counts, etc.). */ public AmazonDynamoDBClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration) { this(awsCredentialsProvider, clientConfiguration, new UrlHttpClient(clientConfiguration)); } /** * Constructs a new client to invoke service methods on AmazonDynamoDB 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 AmazonDynamoDB (ex: proxy * settings, retry counts, etc.). * @param requestMetricCollector optional request metric collector */ @Deprecated public AmazonDynamoDBClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration, RequestMetricCollector requestMetricCollector) { super(adjustClientConfiguration(clientConfiguration), requestMetricCollector); this.awsCredentialsProvider = awsCredentialsProvider; init(); } /** * Constructs a new client to invoke service methods on AmazonDynamoDB 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 AmazonDynamoDB (ex: proxy
* settings, retry counts, etc.).
* @param httpClient A http client
*/
public AmazonDynamoDBClient(AWSCredentialsProvider awsCredentialsProvider,
ClientConfiguration clientConfiguration, HttpClient httpClient) {
super(adjustClientConfiguration(clientConfiguration), httpClient);
this.awsCredentialsProvider = awsCredentialsProvider;
init();
}
private void init() {
jsonErrorUnmarshallers = new ArrayList
* The
* A single operation can retrieve up to 16 MB of data, which can contain as
* many as 100 items.
* If you request more than 100 items
* 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
* If none of the items can be processed due to insufficient
* provisioned throughput on all of the tables in the request, then
*
* 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,
* In order to minimize response latency,
* 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
*
* 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.
*
* Represents the input of a
* The
*
* The individual
* Note that if none of the items can be processed due to
* insufficient provisioned throughput on all of the tables in the request,
* then
* 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
* 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,
* 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
* 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
*
* Your request contains at least two items with identical hash and range
* keys (which essentially is two put operations).
*
* 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.
*
* Represents the input of a
* Creates a backup for an existing table.
*
* Each time you create an On-Demand Backup, the entire table data is backed
* up. There is no limit to the number of on-demand backups that can be
* taken.
*
* When you create an On-Demand Backup, a time marker of the request is
* cataloged, and the backup is created asynchronously, by applying all
* changes until the time of the request to the last full table snapshot.
* Backup requests are processed instantaneously and become available for
* restore within minutes.
*
* You can call
* All backups in DynamoDB work without consuming any provisioned throughput
* on the table.
*
* If you submit a backup request on 2018-12-14 at 14:25:00, the backup is
* guaranteed to contain all data committed to the table up to 14:24:00, and
* data committed after 14:26:00 will not be. The backup may or may not
* contain data modifications made between 14:24:00 and 14:26:00. On-Demand
* Backup does not support causal consistency.
*
* Along with data, the following are also included on the backups:
*
* Global secondary indexes (GSIs)
*
* Local secondary indexes (LSIs)
*
* Streams
*
* Provisioned read and write capacity
*
* Creates a global table from an existing table. A global table creates a
* replication relationship between two or more DynamoDB tables with the
* same table name in the provided regions.
*
* If you want to add a new replica table to a global table, each of the
* following conditions must be true:
*
* The table must have the same primary key as all of the other replicas.
*
* The table must have the same name as all of the other replicas.
*
* The table must have DynamoDB Streams enabled, with the stream containing
* both the new and the old images of the item.
*
* None of the replica tables in the global table can contain any data.
*
* If global secondary indexes are specified, then the following conditions
* must also be met:
*
* The global secondary indexes must have the same name.
*
* The global secondary indexes must have the same hash key and sort key (if
* present).
*
* Write capacity settings should be set consistently across your replica
* tables and secondary indexes. DynamoDB strongly recommends enabling auto
* scaling to manage the write capacity settings for all of your global
* tables replicas and indexes.
*
* If you prefer to manage write capacity settings manually, you should
* provision equal replicated write capacity units to your replica tables.
* You should also provision equal replicated write capacity units to
* matching secondary indexes across your global table.
*
* The
*
* You can optionally define secondary indexes on the new table, as part of
* the
* You can use the
* Represents the input of a
* Deletes an existing backup of a table.
*
* You can call
* 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
* Unless you specify conditions, the
* 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.
*
* Represents the input of a
* The
* DynamoDB might continue to accept data read and write operations, such as
*
* When you delete a table, any indexes on that table are also deleted.
*
* If you have DynamoDB Streams enabled on the table, then the corresponding
* stream on that table goes into the
* Use the
* Represents the input of a
* Describes an existing backup of a table.
*
* You can call
* Checks the status of continuous backups and point in time recovery on the
* specified table. Continuous backups are
* Once continuous backups and point in time recovery are enabled, you can
* restore to any point in time within
*
*
* You can call
* Returns information about the specified global table.
*
* Describes region specific settings for a global table.
*
* 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
*
* For example, you could use one of the AWS SDKs to do the following:
*
* Call
* 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
* For each table name listed by
* Call
* Use the data returned by
* 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
*
* 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.
*
*
* The
* Represents the input of a
* 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
* Represents the input of a
* Gives a description of the Time to Live (TTL) status on the specified
* table.
*
* The
*
* Represents the input of a
* List backups associated with an AWS account. To list backups for a given
* table, specify
* In the request, start time is inclusive but end time is exclusive. Note
* that these limits are for the time at which the original backup was
* requested.
*
* You can call
* Lists all global tables that have a replica in the specified region.
*
* Returns an array of table names associated with the current account and
* endpoint. The output from
* Represents the input of a
* List all tags on an Amazon DynamoDB resource. You can call
* ListTagsOfResource up to 10 times per second, per account.
*
* For an overview on tagging DynamoDB resources, see Tagging for DynamoDB in the Amazon DynamoDB Developer Guide.
*
* 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. You can return the item's attribute values
* in the same operation, using the
* This topic provides general information about the
* For information on how to call the
* 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
*
* To prevent a new item from replacing an existing item, use a conditional
* expression that contains the
* For more information about
* Represents the input of a
* The
* Use the
* A
* DynamoDB calculates the number of read capacity units consumed based on
* item size, not on the amount of data that is returned to an application.
* The number of capacity units consumed will be the same whether you
* request all of the attributes (the default behavior) or just some of them
* (using a projection expression). The number will also be the same whether
* or not you use a
*
* A single
*
* A
* 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
* Represents the input of a
* Creates a new table from an existing backup. Any number of users can
* execute up to 4 concurrent restores (any type of restore) in a given
* account.
*
* You can call
* You must manually set up the following on the restored table:
*
* Auto scaling policies
*
* IAM policies
*
* Cloudwatch metrics and alarms
*
* Tags
*
* Stream settings
*
* Time to Live (TTL) settings
*
* Restores the specified table to the specified point in time within
*
* When you restore using point in time recovery, DynamoDB restores your
* table data to the state based on the selected date and time
* (day:hour:minute:second) to a new table.
*
* Along with data, the following are also included on the new restored
* table using point in time recovery:
*
* Global secondary indexes (GSIs)
*
* Local secondary indexes (LSIs)
*
* Provisioned read and write capacity
*
* Encryption settings
*
* All these settings come from the current settings of the source table at
* the time of restore.
*
* You must manually set up the following on the restored table:
*
* Auto scaling policies
*
* IAM policies
*
* Cloudwatch metrics and alarms
*
* Tags
*
* Stream settings
*
* Time to Live (TTL) settings
*
* Point in time recovery settings
*
* The
* 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
*
* A single
*
*
* Represents the input of a
* Associate a set of tags with an Amazon DynamoDB resource. You can then
* activate these user-defined tags so that they appear on the Billing and
* Cost Management console for cost allocation tracking. You can call
* TagResource up to 5 times per second, per account.
*
* For an overview on tagging DynamoDB resources, see Tagging for DynamoDB in the Amazon DynamoDB Developer Guide.
*
* Removes the association of tags from an Amazon DynamoDB resource. You can
* call UntagResource up to 5 times per second, per account.
*
* For an overview on tagging DynamoDB resources, see Tagging for DynamoDB in the Amazon DynamoDB Developer Guide.
*
*
* Once continuous backups and point in time recovery are enabled, you can
* restore to any point in time within
*
*
* Adds or removes replicas in the specified global table. The global table
* must already exist to be able to use this operation. Any replica to be
* added must be empty, must have the same name as the global table, must
* have the same key schema, and must have DynamoDB Streams enabled and must
* have same provisioned and maximum write capacity units.
*
* Although you can use
* If global secondary indexes are specified, then the following conditions
* must also be met:
*
* The global secondary indexes must have the same name.
*
* The global secondary indexes must have the same hash key and sort key (if
* present).
*
* The global secondary indexes must have the same provisioned and maximum
* write capacity units.
*
* Updates settings for a global table.
*
* 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
*
* Represents the input of an
* 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
*
* Represents the input of an
* The UpdateTimeToLive method will enable or disable TTL for the specified
* table. A successful
* TTL compares the current time in epoch time format to the time stored in
* the TTL attribute of an item. If the epoch time value stored in the
* attribute is less than the current time, the item is marked as expired
* and subsequently deleted.
*
* The epoch time format is the number of seconds elapsed since 12:00:00 AM
* January 1st, 1970 UTC.
*
* DynamoDB deletes expired items on a best-effort basis to ensure
* availability of throughput for other data operations.
*
* DynamoDB typically deletes expired items within two days of expiration.
* The exact duration within which an item gets deleted after expiration is
* specific to the nature of the workload. Items that have expired and not
* been deleted will still show up in reads, queries, and scans.
*
* As items are deleted, they are removed from any Local Secondary Index and
* Global Secondary Index immediately in the same eventually consistent way
* as a standard delete operation.
*
* For more information, see Time To Live in the Amazon DynamoDB Developer Guide.
*
* Represents the input of an
* 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. You can return the item's attribute values
* in the same operation, using the
* This topic provides general information about the
* For information on how to call the
* 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
*
* To prevent a new item from replacing an existing item, use a conditional
* expression that contains the
* For more information about
* The name of the table to contain the item.
*
* A map of attribute name/value pairs, one for each attribute.
* Only the primary key attributes are required; you can
* optionally provide other attribute name-value pairs for the
* item.
*
* You must provide all of the attributes for the primary key.
* For example, with a simple primary key, you only need to
* provide a value for the partition key. For a composite primary
* key, you must provide both values for both the partition key
* and the sort key.
*
* If you specify any attributes that are part of an index key,
* then the data types for those attributes must match those of
* the schema in the table's attribute definition.
*
* For more information about primary keys, see Primary Key in the Amazon DynamoDB Developer
* Guide.
*
* Each element in the
* 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. You can return the item's attribute values
* in the same operation, using the
* This topic provides general information about the
* For information on how to call the
* 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
*
* To prevent a new item from replacing an existing item, use a conditional
* expression that contains the
* For more information about
* The name of the table to contain the item.
*
* A map of attribute name/value pairs, one for each attribute.
* Only the primary key attributes are required; you can
* optionally provide other attribute name-value pairs for the
* item.
*
* You must provide all of the attributes for the primary key.
* For example, with a simple primary key, you only need to
* provide a value for the partition key. For a composite primary
* key, you must provide both values for both the partition key
* and the sort key.
*
* If you specify any attributes that are part of an index key,
* then the data types for those attributes must match those of
* the schema in the table's attribute definition.
*
* For more information about primary keys, see Primary Key in the Amazon DynamoDB Developer
* Guide.
*
* Each element in the
* Use
*
*
* The
* 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
*
* The name of the table containing the item to update.
*
* The primary key of the item to be updated. Each element
* consists of an attribute name and a value for that attribute.
*
* For the primary key, you must provide all of the attributes.
* For example, with a simple primary key, you only need to
* provide a value for the partition key. For a composite primary
* key, you must provide values for both the partition key and
* the sort key.
*
* This is a legacy parameter. Use
* 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
*
* The name of the table containing the item to update.
*
* The primary key of the item to be updated. Each element
* consists of an attribute name and a value for that attribute.
*
* For the primary key, you must provide all of the attributes.
* For example, with a simple primary key, you only need to
* provide a value for the partition key. For a composite primary
* key, you must provide values for both the partition key and
* the sort key.
*
* This is a legacy parameter. Use
* Use
*
*
*
*
*
* There is no additional cost associated with requesting a
* return value aside from the small network and processing
* overhead of receiving a larger response. No read capacity
* units are consumed.
*
* The values returned are strongly consistent.
*
* 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
* The name of the table to describe.
*
* The
* 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
*
* A single
*
*
* The name of the table containing the requested items; or, if
* you provide
* This is a legacy parameter. Use
*
* The
* 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
*
* A single
*
*
* The name of the table containing the requested items; or, if
* you provide
* This is a legacy parameter. Use
* The
* 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
*
* A single
*
*
* The name of the table containing the requested items; or, if
* you provide
* This is a legacy parameter. Use
*
* This is a legacy parameter. Use
* 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
* Unless you specify conditions, the
* 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.
*
* The name of the table from which to delete the item.
*
* A map of attribute names to
* For the primary key, you must provide all of the attributes.
* For example, with a simple primary key, you only need to
* provide a value for the partition key. For a composite primary
* key, you must provide values for both the partition key and
* the sort key.
*
* 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
* Unless you specify conditions, the
* 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.
*
* The name of the table from which to delete the item.
*
* A map of attribute names to
* For the primary key, you must provide all of the attributes.
* For example, with a simple primary key, you only need to
* provide a value for the partition key. For a composite primary
* key, you must provide values for both the partition key and
* the sort key.
*
* Use
*
*
* The
* The
* DynamoDB might continue to accept data read and write operations, such as
*
* When you delete a table, any indexes on that table are also deleted.
*
* If you have DynamoDB Streams enabled on the table, then the corresponding
* stream on that table goes into the
* Use the
* The name of the table to delete.
*
* The
*
* You can optionally define secondary indexes on the new table, as part of
* the
* You can use the
* An array of attributes that describe the key schema for the
* table and indexes.
*
* The name of the table to create.
*
* Specifies the attributes that make up the primary key for a
* table or an index. The attributes in
* Each
*
*
*
*
* The partition key of an item is also known as its hash
* attribute. The term "hash attribute" derives from
* DynamoDB' usage of an internal hash function to evenly
* distribute data items across partitions, based on their
* partition key values.
*
* The sort key of an item is also known as its range
* attribute. The term "range attribute" derives from the way
* DynamoDB stores items with the same partition key physically
* close together, in sorted order by the sort key value.
*
* For a simple primary key (partition key), you must provide
* exactly one element with a
* For a composite primary key (partition key and sort key), you
* must provide exactly two elements, in this order: The first
* element must have a
* For more information, see Specifying the Primary Key in the Amazon DynamoDB
* Developer Guide.
*
* Represents the provisioned throughput settings for a specified
* table or index. The settings can be modified using the
*
* For current minimum and maximum provisioned throughput values,
* see Limits in the Amazon DynamoDB Developer Guide.
*
* The
*
* The name of the table containing the requested item.
*
* A map of attribute names to
* For the primary key, you must provide all of the attributes.
* For example, with a simple primary key, you only need to
* provide a value for the partition key. For a composite primary
* key, you must provide values for both the partition key and
* the sort key.
*
* The
*
* The name of the table containing the requested item.
*
* A map of attribute names to
* For the primary key, you must provide all of the attributes.
* For example, with a simple primary key, you only need to
* provide a value for the partition key. For a composite primary
* key, you must provide values for both the partition key and
* the sort key.
*
* Determines the read consistency model: If set to
*
* Returns an array of table names associated with the current account and
* endpoint. The output from
* Returns an array of table names associated with the current account and
* endpoint. The output from
* The first table name that this operation will evaluate. Use
* the value that was returned for
*
* Returns an array of table names associated with the current account and
* endpoint. The output from
* The first table name that this operation will evaluate. Use
* the value that was returned for
*
* A maximum number of table names to return. If this parameter
* is not specified, the limit is 100.
*
* Returns an array of table names associated with the current account and
* endpoint. The output from
* A maximum number of table names to return. If this parameter
* is not specified, the limit is 100.
*
* 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
*
* The name of the table to be updated.
*
* The new provisioned throughput settings for the specified
* table or index.
*
* The
* A single operation can retrieve up to 16 MB of data, which can contain as
* many as 100 items.
* If you request more than 100 items
* 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
* If none of the items can be processed due to insufficient
* provisioned throughput on all of the tables in the request, then
*
* 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,
* In order to minimize response latency,
* 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
*
* 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.
*
* A map of one or more table names and, for each table, a map
* that describes one or more items to retrieve from that table.
* Each table name can be used only once per
*
* Each element in the map of items to retrieve consists of the
* following:
*
*
*
* To access an attribute whose name conflicts with a DynamoDB
* reserved word.
*
* To create a placeholder for repeating occurrences of an
* attribute name in an expression.
*
* To prevent special characters in an attribute name from being
* misinterpreted in an expression.
*
* Use the # character in an expression to dereference an
* attribute name. For example, consider the following attribute
* name:
*
*
* The name of this attribute conflicts with a reserved word, so
* it cannot be used directly in an expression. (For the complete
* list of reserved words, see Reserved Words in the Amazon DynamoDB Developer
* Guide). To work around this, you could specify the
* following for
*
* You could then use this substitution in an expression, as in
* this example:
*
*
* Tokens that begin with the : character are
* expression attribute values, which are placeholders for
* the actual value at runtime.
*
* For more information on expression attribute names, see Accessing Item Attributes in the Amazon DynamoDB
* Developer Guide.
*
*
*
* If no attribute names are specified, then all attributes will
* be returned. If any of the requested attributes are not found,
* they will not appear in the result.
*
* For more information, see Accessing Item Attributes in the Amazon DynamoDB
* Developer Guide.
*
*
* The
* A single operation can retrieve up to 16 MB of data, which can contain as
* many as 100 items.
* If you request more than 100 items
* 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
* If none of the items can be processed due to insufficient
* provisioned throughput on all of the tables in the request, then
*
* 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,
* In order to minimize response latency,
* 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
*
* 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.
*
* A map of one or more table names and, for each table, a map
* that describes one or more items to retrieve from that table.
* Each table name can be used only once per
*
* Each element in the map of items to retrieve consists of the
* following:
*
*
*
* To access an attribute whose name conflicts with a DynamoDB
* reserved word.
*
* To create a placeholder for repeating occurrences of an
* attribute name in an expression.
*
* To prevent special characters in an attribute name from being
* misinterpreted in an expression.
*
* Use the # character in an expression to dereference an
* attribute name. For example, consider the following attribute
* name:
*
*
* The name of this attribute conflicts with a reserved word, so
* it cannot be used directly in an expression. (For the complete
* list of reserved words, see Reserved Words in the Amazon DynamoDB Developer
* Guide). To work around this, you could specify the
* following for
*
* You could then use this substitution in an expression, as in
* this example:
*
*
* Tokens that begin with the : character are
* expression attribute values, which are placeholders for
* the actual value at runtime.
*
* For more information on expression attribute names, see Accessing Item Attributes in the Amazon DynamoDB
* Developer Guide.
*
*
*
* If no attribute names are specified, then all attributes will
* be returned. If any of the requested attributes are not found,
* they will not appear in the result.
*
* For more information, see Accessing Item Attributes in the Amazon DynamoDB
* Developer Guide.
*
*
* The
*
* The individual
* Note that if none of the items can be processed due to
* insufficient provisioned throughput on all of the tables in the request,
* then
* 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
* 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,
* 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
* 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
*
* Your request contains at least two items with identical hash and range
* keys (which essentially is two put operations).
*
* 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.
*
* A map of one or more table names and, for each table, a list
* of operations to be performed (
*
*
*
*
* If you specify any attributes that are part of an index key,
* then the data types for those attributes must match those of
* the schema in the table's attribute definition.
*
* 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.
* @deprecated ResponseMetadata cache can hold up to 50 requests and
* responses in memory and will cause memory issue. This method
* now always returns null.
*/
@Deprecated
public ResponseMetadata getCachedResponseMetadata(AmazonWebServiceRequest request) {
return client.getResponseMetadataForRequest(request);
}
private BatchGetItem operation returns the attributes of one or
* more items from one or more tables. You identify requested items by
* primary key.
* 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.
* BatchGetItem will return
* a ValidationException with the message
* "Too many items requested for the BatchGetItem call".
* 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.
* 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.
* 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.
* BatchGetItem
* retrieves items in parallel.
* ProjectionExpression parameter.
* BatchGetItem operation.
* 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 action.
* 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.
* BatchWriteItem will return a
* ProvisionedThroughputExceededException.
* 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.
* BatchWriteItem 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.
*
*
*
* @param batchWriteItemRequest BatchWriteItem request
* does not exist.
* BatchWriteItem request. For example, you cannot put and
* delete the same item in the same BatchWriteItem request.
* BatchWriteItem
* operation.
* CreateBackup at a maximum rate of 50 times per
* second.
*
*
*
* @param createBackupRequest
* @return createBackupResult The response from the CreateBackup service
* method, as returned by Amazon DynamoDB.
* @throws TableNotFoundException
* @throws TableInUseException
* @throws ContinuousBackupsUnavailableException
* @throws BackupInUseException
* @throws LimitExceededException
* @throws InternalServerErrorException
* @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 Amazon
* DynamoDB indicating either a problem with the data in the
* request, or a server side issue.
*/
public CreateBackupResult createBackup(CreateBackupRequest createBackupRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(createBackupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request
*
*
*
* 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.
* 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.
* DescribeTable action to check the table
* status.
* CreateTable operation.
* DeleteBackup at a maximum rate of 10 times per
* second.
* ReturnValues
* parameter.
* DeleteItem is an
* idempotent operation; running it multiple times on the same item or
* attribute does not result in an error response.
* DeleteItem operation.
* 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.
* GetItem and PutItem, on a table in the
* DELETING state until the table deletion is complete.
* DISABLED state, and the
* stream is automatically deleted after 24 hours.
* DescribeTable action to check the status of the
* table.
* DeleteTable operation.
* DescribeBackup at a maximum rate of 10 times
* per second.
* ENABLED on all
* tables at table creation. If point in time recovery is enabled,
* PointInTimeRecoveryStatus will be set to ENABLED.
* EarliestRestorableDateTime and
* LatestRestorableDateTime.
* LatestRestorableDateTime is typically 5 minutes before the
* current time. You can restore your table to any point in time during the
* last 35 days.
* DescribeContinuousBackups at a maximum rate of
* 10 times per second.
* DescribeLimits action 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.
*
*
* DescribeLimits for a particular region to obtain your
* current account limits on provisioned capacity there.
* ListTables to obtain a list of all your DynamoDB
* tables.
* ListTables, do the following:
*
*
* DescribeTable with the table name.
* DescribeTable to add the read
* capacity units and write capacity units provisioned for the table itself
* to your variables.
* DescribeLimits, along with the total current provisioned
* capacity levels you have calculated.
* DescribeLimits should only be called periodically. You can
* expect throttling errors if you call it more than once in a minute.
* DescribeLimits Request element has no content.
* DescribeLimits
* operation. Has no content.
* DescribeTable request immediately after a
* CreateTable request, DynamoDB might return a
* ResourceNotFoundException. This is because
* DescribeTable uses an eventually consistent query, and the
* metadata for your table might not be available at that moment. Wait for a
* few seconds, and then try the DescribeTable request again.
* DescribeTable
* operation.
* 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 and there will be no
* Item element in the response.
* 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.
* GetItem operation.
* TableName. ListBackups returns a
* paginated list of results with at most 1MB worth of items in a page. You
* can also specify a limit for the maximum number of entries to be returned
* in a page.
* ListBackups a maximum of 5 times per second.
* ListTables is paginated, with each
* page returning a maximum of 100 table names.
* ListTables operation.
* ReturnValues parameter.
* PutItem
* API.
* PutItem API using the AWS
* SDK in specific languages, see the following:
*
*
* ValidationException exception.
* 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.
* PutItem, see Working with Items in the Amazon DynamoDB Developer Guide.
* PutItem operation.
* Query operation finds items based on primary key values.
* You can query any table or secondary index that has a composite primary
* key (a partition key and a sort key).
* 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. To further refine the
* Query results, you can optionally provide a
* FilterExpression. A FilterExpression determines
* which items within the results should be returned to you. All of the
* other results are discarded.
* Query operation always returns a result set. If no
* matching items are found, the result set will be empty. Queries that do
* not return results consume the minimum number of read capacity units for
* that type of read operation.
* FilterExpression.
* Query results are always sorted by the sort key value. If
* the data type of the sort key is Number, the results are returned in
* numeric order; otherwise, the results are returned in order of UTF-8
* bytes. By default, the sort order is ascending. To reverse the order, set
* the ScanIndexForward parameter to false.
* Query operation will read up to the maximum number
* of items set (if using the Limit parameter) or a maximum of
* 1 MB of data and then apply any filtering to the results using
* FilterExpression. If LastEvaluatedKey is
* present in the response, you will need to paginate the result set. For
* more information, see Paginating the Results in the Amazon DynamoDB Developer
* Guide.
* FilterExpression is applied after a Query
* finishes, but before the results are returned. A
* FilterExpression cannot contain partition key or sort key
* attributes. You need to specify those attributes in the
* KeyConditionExpression.
* Query operation can return an empty result set and a
* LastEvaluatedKey if all the items read for the page of
* results are filtered out.
* 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.
* Query operation.
* RestoreTableFromBackup at a maximum rate of 10
* times per second.
*
*
*
* @param restoreTableFromBackupRequest
* @return restoreTableFromBackupResult The response from the
* RestoreTableFromBackup service method, as returned by Amazon
* DynamoDB.
* @throws TableAlreadyExistsException
* @throws TableInUseException
* @throws BackupNotFoundException
* @throws BackupInUseException
* @throws LimitExceededException
* @throws InternalServerErrorException
* @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 Amazon
* DynamoDB indicating either a problem with the data in the
* request, or a server side issue.
*/
public RestoreTableFromBackupResult restoreTableFromBackup(
RestoreTableFromBackupRequest restoreTableFromBackupRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(restoreTableFromBackupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
RequestEarliestRestorableDateTime and
* LatestRestorableDateTime. You can restore your table to any
* point in time during the last 35 days. Any number of users can execute up
* to 4 concurrent restores (any type of restore) in a given account.
*
*
*
*
*
* @param restoreTableToPointInTimeRequest
* @return restoreTableToPointInTimeResult The response from the
* RestoreTableToPointInTime service method, as returned by Amazon
* DynamoDB.
* @throws TableAlreadyExistsException
* @throws TableNotFoundException
* @throws TableInUseException
* @throws LimitExceededException
* @throws InvalidRestoreTimeException
* @throws PointInTimeRecoveryUnavailableException
* @throws InternalServerErrorException
* @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 Amazon
* DynamoDB indicating either a problem with the data in the
* request, or a server side issue.
*/
public RestoreTableToPointInTimeResult restoreTableToPointInTime(
RestoreTableToPointInTimeRequest restoreTableToPointInTimeRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(restoreTableToPointInTimeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
RequestScan 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
* FilterExpression operation.
* 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.
* Scan operation will read up to the maximum number
* of items set (if using the Limit parameter) or a maximum of
* 1 MB of data and then apply any filtering to the results using
* FilterExpression. If LastEvaluatedKey is
* present in the response, you will need to paginate the result set. For
* more information, see Paginating the Results in the Amazon DynamoDB Developer
* Guide.
* 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.
* Scan uses eventually consistent reads when accessing the
* data in a table; therefore, the result set might not include the changes
* to data in the table immediately before the operation began. If you need
* a consistent copy of the data, as of the time that the Scan
* begins, you can set the ConsistentRead parameter to
* true.
* Scan operation.
* UpdateContinuousBackups enables or disables point in time
* recovery for the specified table. A successful
* UpdateContinuousBackups call returns the current
* ContinuousBackupsDescription. Continuous backups are
* ENABLED on all tables at table creation. If point in time
* recovery is enabled, PointInTimeRecoveryStatus will be set
* to ENABLED.
* EarliestRestorableDateTime and
* LatestRestorableDateTime.
* LatestRestorableDateTime is typically 5 minutes before the
* current time. You can restore your table to any point in time during the
* last 35 days..
* UpdateGlobalTable to add replicas and
* remove replicas in a single request, for simplicity we recommend that you
* issue separate requests for adding or removing replicas.
*
*
*
* @param updateGlobalTableRequest
* @return updateGlobalTableResult The response from the UpdateGlobalTable
* service method, as returned by Amazon DynamoDB.
* @throws InternalServerErrorException
* @throws GlobalTableNotFoundException
* @throws ReplicaAlreadyExistsException
* @throws ReplicaNotFoundException
* @throws TableNotFoundException
* @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 Amazon
* DynamoDB indicating either a problem with the data in the
* request, or a server side issue.
*/
public UpdateGlobalTableResult updateGlobalTable(
UpdateGlobalTableRequest updateGlobalTableRequest)
throws AmazonServiceException, AmazonClientException {
ExecutionContext executionContext = createExecutionContext(updateGlobalTableRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
RequestUpdateItem operation using the ReturnValues
* parameter.
* UpdateItem operation.
*
*
* 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.
* UpdateTable operation.
* UpdateTimeToLive call returns the
* current TimeToLiveSpecification; it may take up to one hour
* for the change to fully process. Any additional
* UpdateTimeToLive calls for the same table during this one
* hour duration result in a ValidationException.
* UpdateTimeToLive
* operation.
* ReturnValues parameter.
* PutItem
* API.
* PutItem API using the AWS
* SDK in specific languages, see the following:
*
*
* ValidationException exception.
* 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.
* PutItem, see Working with Items in the Amazon DynamoDB Developer Guide.
* Item map is an
* AttributeValue object.
* ReturnValues parameter.
* PutItem
* API.
* PutItem API using the AWS
* SDK in specific languages, see the following:
*
*
* ValidationException exception.
* 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.
* PutItem, see Working with Items in the Amazon DynamoDB Developer Guide.
* Item map is an
* AttributeValue object.
* ReturnValues if you want to get the item
* attributes as they appeared before they were updated with the
* PutItem request. For PutItem, the
* valid values are:
*
*
* NONE - If ReturnValues is not
* specified, or if its value is NONE, then nothing
* is returned. (This setting is the default for
* ReturnValues.)
* ALL_OLD - If PutItem overwrote an
* attribute name-value pair, then the content of the old item is
* returned.
* ReturnValues parameter is used by several
* DynamoDB operations; however, PutItem does not
* recognize any values other than NONE or
* ALL_OLD.
* UpdateItem operation using the ReturnValues
* parameter.
* UpdateExpression
* instead. For more information, see AttributeUpdates in the Amazon DynamoDB Developer
* Guide.
* UpdateItem operation using the ReturnValues
* parameter.
* UpdateExpression
* instead. For more information, see AttributeUpdates in the Amazon DynamoDB Developer
* Guide.
* ReturnValues if you want to get the item
* attributes as they appear before or after they are updated.
* For UpdateItem, the valid values are:
*
*
* NONE - If ReturnValues is not
* specified, or if its value is NONE, then nothing
* is returned. (This setting is the default for
* ReturnValues.)
* ALL_OLD - Returns all of the attributes of the
* item, as they appeared before the UpdateItem operation.
* UPDATED_OLD - Returns only the updated
* attributes, as they appeared before the UpdateItem operation.
* ALL_NEW - Returns all of the attributes of the
* item, as they appear after the UpdateItem operation.
* UPDATED_NEW - Returns only the updated
* attributes, as they appear after the UpdateItem operation.
* 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.
* 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
* FilterExpression operation.
* 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.
* Scan operation will read up to the maximum number
* of items set (if using the Limit parameter) or a maximum of
* 1 MB of data and then apply any filtering to the results using
* FilterExpression. If LastEvaluatedKey is
* present in the response, you will need to paginate the result set. For
* more information, see Paginating the Results in the Amazon DynamoDB Developer
* Guide.
* 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.
* 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.
* IndexName, the name of the table to
* which that index belongs.
* ProjectionExpression instead. For more
* information, see AttributesToGet in the Amazon DynamoDB Developer
* Guide.
* 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
* FilterExpression operation.
* 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.
* Scan operation will read up to the maximum number
* of items set (if using the Limit parameter) or a maximum of
* 1 MB of data and then apply any filtering to the results using
* FilterExpression. If LastEvaluatedKey is
* present in the response, you will need to paginate the result set. For
* more information, see Paginating the Results in the Amazon DynamoDB Developer
* Guide.
* 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.
* 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.
* IndexName, the name of the table to
* which that index belongs.
* FilterExpression
* instead. For more information, see ScanFilter in the Amazon DynamoDB Developer Guide.
* 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
* FilterExpression operation.
* 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.
* Scan operation will read up to the maximum number
* of items set (if using the Limit parameter) or a maximum of
* 1 MB of data and then apply any filtering to the results using
* FilterExpression. If LastEvaluatedKey is
* present in the response, you will need to paginate the result set. For
* more information, see Paginating the Results in the Amazon DynamoDB Developer
* Guide.
* 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.
* 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.
* IndexName, the name of the table to
* which that index belongs.
* ProjectionExpression instead. For more
* information, see AttributesToGet in the Amazon DynamoDB Developer
* Guide.
* FilterExpression
* instead. For more information, see ScanFilter in the Amazon DynamoDB Developer Guide.
* ReturnValues
* parameter.
* DeleteItem is an
* idempotent operation; running it multiple times on the same item or
* attribute does not result in an error response.
* AttributeValue
* objects, representing the primary key of the item to delete.
* ReturnValues
* parameter.
* DeleteItem is an
* idempotent operation; running it multiple times on the same item or
* attribute does not result in an error response.
* AttributeValue
* objects, representing the primary key of the item to delete.
* ReturnValues if you want to get the item
* attributes as they appeared before they were deleted. For
* DeleteItem, the valid values are:
*
*
* NONE - If ReturnValues is not
* specified, or if its value is NONE, then nothing
* is returned. (This setting is the default for
* ReturnValues.)
* ALL_OLD - The content of the old item is
* returned.
* ReturnValues parameter is used by several
* DynamoDB operations; however, DeleteItem does not
* recognize any values other than NONE or
* ALL_OLD.
* 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.
* GetItem and PutItem, on a table in the
* DELETING state until the table deletion is complete.
* DISABLED state, and the
* stream is automatically deleted after 24 hours.
* DescribeTable action to check the status of the
* table.
* 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.
* 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.
* DescribeTable action to check the table
* status.
* KeySchema
* must also be defined in the AttributeDefinitions
* array. For more information, see Data Model in the Amazon DynamoDB Developer Guide.
* KeySchemaElement in the array is composed
* of:
*
*
* AttributeName - The name of this key attribute.
* KeyType - The role that the key attribute will
* assume:
*
*
* HASH - partition key
* RANGE - sort key
* KeyType of
* HASH.
* KeyType of HASH,
* and the second element must have a KeyType of
* RANGE.
* UpdateTable operation.
* 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 and there will be no
* Item element in the response.
* 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.
* AttributeValue
* objects, representing the primary key of the item to retrieve.
* 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 and there will be no
* Item element in the response.
* 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.
* AttributeValue
* objects, representing the primary key of the item to retrieve.
* true, then the operation uses strongly consistent
* reads; otherwise, the operation uses eventually consistent
* reads.
* ListTables is paginated, with each
* page returning a maximum of 100 table names.
* ListTables is paginated, with each
* page returning a maximum of 100 table names.
* LastEvaluatedTableName in a previous operation,
* so that you can obtain the next page of results.
* ListTables is paginated, with each
* page returning a maximum of 100 table names.
* LastEvaluatedTableName in a previous operation,
* so that you can obtain the next page of results.
* ListTables is paginated, with each
* page returning a maximum of 100 table names.
*
*
* 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.
* BatchGetItem operation returns the attributes of one or
* more items from one or more tables. You identify requested items by
* primary key.
* 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.
* BatchGetItem will return
* a ValidationException with the message
* "Too many items requested for the BatchGetItem call".
* 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.
* 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.
* 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.
* BatchGetItem
* retrieves items in parallel.
* ProjectionExpression parameter.
* BatchGetItem request.
*
*
* @param returnConsumedCapacity
* @return batchGetItemResult The response from the BatchGetItem service
* method, as returned by Amazon DynamoDB.
* @throws ProvisionedThroughputExceededException
* @throws ResourceNotFoundException
* @throws InternalServerErrorException
* @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 Amazon
* DynamoDB indicating either a problem with the data in the
* request, or a server side issue.
*/
public BatchGetItemResult batchGetItem(java.util.MapConsistentRead - If true, a strongly
* consistent read is used; if false (the default),
* an eventually consistent read is used.
* ExpressionAttributeNames - One or more
* substitution tokens for attribute names in the
* ProjectionExpression parameter. The following are
* some use cases for using ExpressionAttributeNames
* :
*
*
*
*
* Percentile
* ExpressionAttributeNames:
*
*
* {"#P":"Percentile"}
*
*
* #P = :val
* Keys - An array of primary key attribute values
* that define specific items in the table. For each primary key,
* you must provide all of the key attributes. For
* example, with a simple primary key, you only need to provide
* the partition key value. For a composite key, you must provide
* both the partition key value and the sort key value.
* ProjectionExpression - A string that identifies
* one or more attributes to retrieve from the table. These
* attributes can include scalars, sets, or elements of a JSON
* document. The attributes in the expression must be separated
* by commas.
* AttributesToGet - This is a legacy parameter. Use
* ProjectionExpression instead. For more
* information, see AttributesToGet in the Amazon DynamoDB Developer
* Guide.
* BatchGetItem operation returns the attributes of one or
* more items from one or more tables. You identify requested items by
* primary key.
* 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.
* BatchGetItem will return
* a ValidationException with the message
* "Too many items requested for the BatchGetItem call".
* 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.
* 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.
* 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.
* BatchGetItem
* retrieves items in parallel.
* ProjectionExpression parameter.
* BatchGetItem request.
*
*
* @return batchGetItemResult The response from the BatchGetItem service
* method, as returned by Amazon DynamoDB.
* @throws ProvisionedThroughputExceededException
* @throws ResourceNotFoundException
* @throws InternalServerErrorException
* @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 Amazon
* DynamoDB indicating either a problem with the data in the
* request, or a server side issue.
*/
public BatchGetItemResult batchGetItem(java.util.MapConsistentRead - If true, a strongly
* consistent read is used; if false (the default),
* an eventually consistent read is used.
* ExpressionAttributeNames - One or more
* substitution tokens for attribute names in the
* ProjectionExpression parameter. The following are
* some use cases for using ExpressionAttributeNames
* :
*
*
*
*
* Percentile
* ExpressionAttributeNames:
*
*
* {"#P":"Percentile"}
*
*
* #P = :val
* Keys - An array of primary key attribute values
* that define specific items in the table. For each primary key,
* you must provide all of the key attributes. For
* example, with a simple primary key, you only need to provide
* the partition key value. For a composite key, you must provide
* both the partition key value and the sort key value.
* ProjectionExpression - A string that identifies
* one or more attributes to retrieve from the table. These
* attributes can include scalars, sets, or elements of a JSON
* document. The attributes in the expression must be separated
* by commas.
* AttributesToGet - This is a legacy parameter. Use
* ProjectionExpression instead. For more
* information, see AttributesToGet in the Amazon DynamoDB Developer
* Guide.
* 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 action.
* 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.
* BatchWriteItem will return a
* ProvisionedThroughputExceededException.
* 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.
* BatchWriteItem 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.
*
*
*
* @param requestItems BatchWriteItem request
* does not exist.
* BatchWriteItem request. For example, you cannot put and
* delete the same item in the same BatchWriteItem request.
* DeleteRequest or
* PutRequest). Each element in the map consists of
* the following:
*
*
* @return batchWriteItemResult The response from the BatchWriteItem service
* method, as returned by Amazon DynamoDB.
* @throws ProvisionedThroughputExceededException
* @throws ResourceNotFoundException
* @throws ItemCollectionSizeLimitExceededException
* @throws InternalServerErrorException
* @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 Amazon
* DynamoDB indicating either a problem with the data in the
* request, or a server side issue.
*/
public BatchWriteItemResult batchWriteItem(
java.util.MapDeleteRequest - Perform a DeleteItem
* operation on the specified item. The item to be deleted is
* identified by a Key subelement:
*
*
* Key - A map of primary key attribute values that
* uniquely identify the item. Each entry in this map consists of
* an attribute name and an attribute value. For each primary
* key, you must provide all of the key attributes. For
* example, with a simple primary key, you only need to provide a
* value for the partition key. For a composite primary key, you
* must provide values for both the partition key and the
* sort key.
* PutRequest - Perform a PutItem
* operation on the specified item. The item to be put is
* identified by an Item subelement:
*
*
* Item - A map of attributes and their values. Each
* entry in this map consists of an attribute name and an
* attribute value. Attribute values must not be null; string and
* binary type attributes must have lengths greater than zero;
* and set type attributes must not be empty. Requests that
* contain empty values will be rejected with a
* ValidationException exception.
*