/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace Aws { namespace Http { class HttpClient; class HttpClientFactory; } // namespace Http namespace Utils { template< typename R, typename E> class Outcome; namespace Threading { class Executor; } // namespace Threading } // namespace Utils namespace Auth { class AWSCredentials; class AWSCredentialsProvider; } // namespace Auth namespace Client { class RetryStrategy; } // namespace Client namespace DynamoDB { namespace Model { class BatchGetItemRequest; class BatchWriteItemRequest; class CreateBackupRequest; class CreateGlobalTableRequest; class CreateTableRequest; class DeleteBackupRequest; class DeleteItemRequest; class DeleteTableRequest; class DescribeBackupRequest; class DescribeContinuousBackupsRequest; class DescribeContributorInsightsRequest; class DescribeEndpointsRequest; class DescribeGlobalTableRequest; class DescribeGlobalTableSettingsRequest; class DescribeLimitsRequest; class DescribeTableRequest; class DescribeTableReplicaAutoScalingRequest; class DescribeTimeToLiveRequest; class GetItemRequest; class ListBackupsRequest; class ListContributorInsightsRequest; class ListGlobalTablesRequest; class ListTablesRequest; class ListTagsOfResourceRequest; class PutItemRequest; class QueryRequest; class RestoreTableFromBackupRequest; class RestoreTableToPointInTimeRequest; class ScanRequest; class TagResourceRequest; class TransactGetItemsRequest; class TransactWriteItemsRequest; class UntagResourceRequest; class UpdateContinuousBackupsRequest; class UpdateContributorInsightsRequest; class UpdateGlobalTableRequest; class UpdateGlobalTableSettingsRequest; class UpdateItemRequest; class UpdateTableRequest; class UpdateTableReplicaAutoScalingRequest; class UpdateTimeToLiveRequest; typedef Aws::Utils::Outcome BatchGetItemOutcome; typedef Aws::Utils::Outcome BatchWriteItemOutcome; typedef Aws::Utils::Outcome CreateBackupOutcome; typedef Aws::Utils::Outcome CreateGlobalTableOutcome; typedef Aws::Utils::Outcome CreateTableOutcome; typedef Aws::Utils::Outcome DeleteBackupOutcome; typedef Aws::Utils::Outcome DeleteItemOutcome; typedef Aws::Utils::Outcome DeleteTableOutcome; typedef Aws::Utils::Outcome DescribeBackupOutcome; typedef Aws::Utils::Outcome DescribeContinuousBackupsOutcome; typedef Aws::Utils::Outcome DescribeContributorInsightsOutcome; typedef Aws::Utils::Outcome DescribeEndpointsOutcome; typedef Aws::Utils::Outcome DescribeGlobalTableOutcome; typedef Aws::Utils::Outcome DescribeGlobalTableSettingsOutcome; typedef Aws::Utils::Outcome DescribeLimitsOutcome; typedef Aws::Utils::Outcome DescribeTableOutcome; typedef Aws::Utils::Outcome DescribeTableReplicaAutoScalingOutcome; typedef Aws::Utils::Outcome DescribeTimeToLiveOutcome; typedef Aws::Utils::Outcome GetItemOutcome; typedef Aws::Utils::Outcome ListBackupsOutcome; typedef Aws::Utils::Outcome ListContributorInsightsOutcome; typedef Aws::Utils::Outcome ListGlobalTablesOutcome; typedef Aws::Utils::Outcome ListTablesOutcome; typedef Aws::Utils::Outcome ListTagsOfResourceOutcome; typedef Aws::Utils::Outcome PutItemOutcome; typedef Aws::Utils::Outcome QueryOutcome; typedef Aws::Utils::Outcome RestoreTableFromBackupOutcome; typedef Aws::Utils::Outcome RestoreTableToPointInTimeOutcome; typedef Aws::Utils::Outcome ScanOutcome; typedef Aws::Utils::Outcome TagResourceOutcome; typedef Aws::Utils::Outcome TransactGetItemsOutcome; typedef Aws::Utils::Outcome TransactWriteItemsOutcome; typedef Aws::Utils::Outcome UntagResourceOutcome; typedef Aws::Utils::Outcome UpdateContinuousBackupsOutcome; typedef Aws::Utils::Outcome UpdateContributorInsightsOutcome; typedef Aws::Utils::Outcome UpdateGlobalTableOutcome; typedef Aws::Utils::Outcome UpdateGlobalTableSettingsOutcome; typedef Aws::Utils::Outcome UpdateItemOutcome; typedef Aws::Utils::Outcome UpdateTableOutcome; typedef Aws::Utils::Outcome UpdateTableReplicaAutoScalingOutcome; typedef Aws::Utils::Outcome UpdateTimeToLiveOutcome; typedef std::future BatchGetItemOutcomeCallable; typedef std::future BatchWriteItemOutcomeCallable; typedef std::future CreateBackupOutcomeCallable; typedef std::future CreateGlobalTableOutcomeCallable; typedef std::future CreateTableOutcomeCallable; typedef std::future DeleteBackupOutcomeCallable; typedef std::future DeleteItemOutcomeCallable; typedef std::future DeleteTableOutcomeCallable; typedef std::future DescribeBackupOutcomeCallable; typedef std::future DescribeContinuousBackupsOutcomeCallable; typedef std::future DescribeContributorInsightsOutcomeCallable; typedef std::future DescribeEndpointsOutcomeCallable; typedef std::future DescribeGlobalTableOutcomeCallable; typedef std::future DescribeGlobalTableSettingsOutcomeCallable; typedef std::future DescribeLimitsOutcomeCallable; typedef std::future DescribeTableOutcomeCallable; typedef std::future DescribeTableReplicaAutoScalingOutcomeCallable; typedef std::future DescribeTimeToLiveOutcomeCallable; typedef std::future GetItemOutcomeCallable; typedef std::future ListBackupsOutcomeCallable; typedef std::future ListContributorInsightsOutcomeCallable; typedef std::future ListGlobalTablesOutcomeCallable; typedef std::future ListTablesOutcomeCallable; typedef std::future ListTagsOfResourceOutcomeCallable; typedef std::future PutItemOutcomeCallable; typedef std::future QueryOutcomeCallable; typedef std::future RestoreTableFromBackupOutcomeCallable; typedef std::future RestoreTableToPointInTimeOutcomeCallable; typedef std::future ScanOutcomeCallable; typedef std::future TagResourceOutcomeCallable; typedef std::future TransactGetItemsOutcomeCallable; typedef std::future TransactWriteItemsOutcomeCallable; typedef std::future UntagResourceOutcomeCallable; typedef std::future UpdateContinuousBackupsOutcomeCallable; typedef std::future UpdateContributorInsightsOutcomeCallable; typedef std::future UpdateGlobalTableOutcomeCallable; typedef std::future UpdateGlobalTableSettingsOutcomeCallable; typedef std::future UpdateItemOutcomeCallable; typedef std::future UpdateTableOutcomeCallable; typedef std::future UpdateTableReplicaAutoScalingOutcomeCallable; typedef std::future UpdateTimeToLiveOutcomeCallable; } // namespace Model class DynamoDBClient; typedef std::function&) > BatchGetItemResponseReceivedHandler; typedef std::function&) > BatchWriteItemResponseReceivedHandler; typedef std::function&) > CreateBackupResponseReceivedHandler; typedef std::function&) > CreateGlobalTableResponseReceivedHandler; typedef std::function&) > CreateTableResponseReceivedHandler; typedef std::function&) > DeleteBackupResponseReceivedHandler; typedef std::function&) > DeleteItemResponseReceivedHandler; typedef std::function&) > DeleteTableResponseReceivedHandler; typedef std::function&) > DescribeBackupResponseReceivedHandler; typedef std::function&) > DescribeContinuousBackupsResponseReceivedHandler; typedef std::function&) > DescribeContributorInsightsResponseReceivedHandler; typedef std::function&) > DescribeEndpointsResponseReceivedHandler; typedef std::function&) > DescribeGlobalTableResponseReceivedHandler; typedef std::function&) > DescribeGlobalTableSettingsResponseReceivedHandler; typedef std::function&) > DescribeLimitsResponseReceivedHandler; typedef std::function&) > DescribeTableResponseReceivedHandler; typedef std::function&) > DescribeTableReplicaAutoScalingResponseReceivedHandler; typedef std::function&) > DescribeTimeToLiveResponseReceivedHandler; typedef std::function&) > GetItemResponseReceivedHandler; typedef std::function&) > ListBackupsResponseReceivedHandler; typedef std::function&) > ListContributorInsightsResponseReceivedHandler; typedef std::function&) > ListGlobalTablesResponseReceivedHandler; typedef std::function&) > ListTablesResponseReceivedHandler; typedef std::function&) > ListTagsOfResourceResponseReceivedHandler; typedef std::function&) > PutItemResponseReceivedHandler; typedef std::function&) > QueryResponseReceivedHandler; typedef std::function&) > RestoreTableFromBackupResponseReceivedHandler; typedef std::function&) > RestoreTableToPointInTimeResponseReceivedHandler; typedef std::function&) > ScanResponseReceivedHandler; typedef std::function&) > TagResourceResponseReceivedHandler; typedef std::function&) > TransactGetItemsResponseReceivedHandler; typedef std::function&) > TransactWriteItemsResponseReceivedHandler; typedef std::function&) > UntagResourceResponseReceivedHandler; typedef std::function&) > UpdateContinuousBackupsResponseReceivedHandler; typedef std::function&) > UpdateContributorInsightsResponseReceivedHandler; typedef std::function&) > UpdateGlobalTableResponseReceivedHandler; typedef std::function&) > UpdateGlobalTableSettingsResponseReceivedHandler; typedef std::function&) > UpdateItemResponseReceivedHandler; typedef std::function&) > UpdateTableResponseReceivedHandler; typedef std::function&) > UpdateTableReplicaAutoScalingResponseReceivedHandler; typedef std::function&) > UpdateTimeToLiveResponseReceivedHandler; /** * Amazon DynamoDB

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.

*/ class AWS_DYNAMODB_API DynamoDBClient : public Aws::Client::AWSJsonClient { public: typedef Aws::Client::AWSJsonClient BASECLASS; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ DynamoDBClient(const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration()); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ DynamoDBClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ DynamoDBClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration()); virtual ~DynamoDBClient(); /** *

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 returns 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 returns 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 dataset.

If none of the items can be processed * due to insufficient provisioned throughput on all of the tables in the request, * then BatchGetItem returns 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 * ProjectionExpression 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 Working * with Tables in the Amazon DynamoDB Developer Guide.

See * Also:

AWS * API Reference

*/ virtual Model::BatchGetItemOutcome BatchGetItem(const Model::BatchGetItemRequest& request) const; /** *

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 returns 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 returns 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 dataset.

If none of the items can be processed * due to insufficient provisioned throughput on all of the tables in the request, * then BatchGetItem returns 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 * ProjectionExpression 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 Working * with Tables in the Amazon DynamoDB Developer Guide.

See * Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::BatchGetItemOutcomeCallable BatchGetItemCallable(const Model::BatchGetItemRequest& request) const; /** *

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 returns 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 returns 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 dataset.

If none of the items can be processed * due to insufficient provisioned throughput on all of the tables in the request, * then BatchGetItem returns 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 * ProjectionExpression 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 Working * with Tables in the Amazon DynamoDB Developer Guide.

See * Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void BatchGetItemAsync(const Model::BatchGetItemRequest& request, const BatchGetItemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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 action.

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.

If * none of the items can be processed due to insufficient provisioned * throughput on all of the tables in the request, then BatchWriteItem * returns 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 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 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.

  • * 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.

    *

See Also:

AWS * API Reference

*/ virtual Model::BatchWriteItemOutcome BatchWriteItem(const Model::BatchWriteItemRequest& request) const; /** *

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 action.

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.

If * none of the items can be processed due to insufficient provisioned * throughput on all of the tables in the request, then BatchWriteItem * returns 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 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 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.

  • * 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.

    *

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::BatchWriteItemOutcomeCallable BatchWriteItemCallable(const Model::BatchWriteItemRequest& request) const; /** *

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 action.

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.

If * none of the items can be processed due to insufficient provisioned * throughput on all of the tables in the request, then BatchWriteItem * returns 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 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 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.

  • * 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.

    *

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void BatchWriteItemAsync(const Model::BatchWriteItemRequest& request, const BatchWriteItemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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 * CreateBackup at a maximum rate of 50 times per second.

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 might 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

See Also:

* AWS * API Reference

*/ virtual Model::CreateBackupOutcome CreateBackup(const Model::CreateBackupRequest& request) const; /** *

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 * CreateBackup at a maximum rate of 50 times per second.

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 might 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

See Also:

* AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::CreateBackupOutcomeCallable CreateBackupCallable(const Model::CreateBackupRequest& request) const; /** *

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 * CreateBackup at a maximum rate of 50 times per second.

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 might 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

See Also:

* AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void CreateBackupAsync(const Model::CreateBackupRequest& request, const CreateBackupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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.

This operation only applies to Version * 2017.11.29 of global tables.

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).

*

If local secondary indexes are specified, then the following conditions must * also be met:

  • The local secondary indexes must have the same * name.

  • The local 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.

See Also:

AWS * API Reference

*/ virtual Model::CreateGlobalTableOutcome CreateGlobalTable(const Model::CreateGlobalTableRequest& request) const; /** *

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.

This operation only applies to Version * 2017.11.29 of global tables.

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).

*

If local secondary indexes are specified, then the following conditions must * also be met:

  • The local secondary indexes must have the same * name.

  • The local 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.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::CreateGlobalTableOutcomeCallable CreateGlobalTableCallable(const Model::CreateGlobalTableRequest& request) const; /** *

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.

This operation only applies to Version * 2017.11.29 of global tables.

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).

*

If local secondary indexes are specified, then the following conditions must * also be met:

  • The local secondary indexes must have the same * name.

  • The local 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.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void CreateGlobalTableAsync(const Model::CreateGlobalTableRequest& request, const CreateGlobalTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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 action to check the table status.

See * Also:

AWS * API Reference

*/ virtual Model::CreateTableOutcome CreateTable(const Model::CreateTableRequest& request) const; /** *

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 action to check the table status.

See * Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::CreateTableOutcomeCallable CreateTableCallable(const Model::CreateTableRequest& request) const; /** *

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 action to check the table status.

See * Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void CreateTableAsync(const Model::CreateTableRequest& request, const CreateTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Deletes an existing backup of a table.

You can call * DeleteBackup at a maximum rate of 10 times per * second.

See Also:

AWS * API Reference

*/ virtual Model::DeleteBackupOutcome DeleteBackup(const Model::DeleteBackupRequest& request) const; /** *

Deletes an existing backup of a table.

You can call * DeleteBackup at a maximum rate of 10 times per * second.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DeleteBackupOutcomeCallable DeleteBackupCallable(const Model::DeleteBackupRequest& request) const; /** *

Deletes an existing backup of a table.

You can call * DeleteBackup at a maximum rate of 10 times per * second.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DeleteBackupAsync(const Model::DeleteBackupRequest& request, const DeleteBackupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::DeleteItemOutcome DeleteItem(const Model::DeleteItemRequest& request) const; /** *

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.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DeleteItemOutcomeCallable DeleteItemCallable(const Model::DeleteItemRequest& request) const; /** *

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.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DeleteItemAsync(const Model::DeleteItemRequest& request, const DeleteItemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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 action to check the status of the table. *

See Also:

AWS * API Reference

*/ virtual Model::DeleteTableOutcome DeleteTable(const Model::DeleteTableRequest& request) const; /** *

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 action to check the status of the table. *

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DeleteTableOutcomeCallable DeleteTableCallable(const Model::DeleteTableRequest& request) const; /** *

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 action to check the status of the table. *

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DeleteTableAsync(const Model::DeleteTableRequest& request, const DeleteTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Describes an existing backup of a table.

You can call * DescribeBackup at a maximum rate of 10 times per * second.

See Also:

AWS * API Reference

*/ virtual Model::DescribeBackupOutcome DescribeBackup(const Model::DescribeBackupRequest& request) const; /** *

Describes an existing backup of a table.

You can call * DescribeBackup at a maximum rate of 10 times per * second.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeBackupOutcomeCallable DescribeBackupCallable(const Model::DescribeBackupRequest& request) const; /** *

Describes an existing backup of a table.

You can call * DescribeBackup at a maximum rate of 10 times per * second.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeBackupAsync(const Model::DescribeBackupRequest& request, const DescribeBackupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Checks the status of continuous backups and point in time recovery on the * specified table. Continuous backups are ENABLED on all tables at * table creation. If point in time recovery is enabled, * PointInTimeRecoveryStatus will be set to ENABLED.

After * continuous backups and point in time recovery are enabled, you can restore to * any point in time within 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. *

You can call DescribeContinuousBackups at a maximum rate of * 10 times per second.

See Also:

AWS * API Reference

*/ virtual Model::DescribeContinuousBackupsOutcome DescribeContinuousBackups(const Model::DescribeContinuousBackupsRequest& request) const; /** *

Checks the status of continuous backups and point in time recovery on the * specified table. Continuous backups are ENABLED on all tables at * table creation. If point in time recovery is enabled, * PointInTimeRecoveryStatus will be set to ENABLED.

After * continuous backups and point in time recovery are enabled, you can restore to * any point in time within 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. *

You can call DescribeContinuousBackups at a maximum rate of * 10 times per second.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeContinuousBackupsOutcomeCallable DescribeContinuousBackupsCallable(const Model::DescribeContinuousBackupsRequest& request) const; /** *

Checks the status of continuous backups and point in time recovery on the * specified table. Continuous backups are ENABLED on all tables at * table creation. If point in time recovery is enabled, * PointInTimeRecoveryStatus will be set to ENABLED.

After * continuous backups and point in time recovery are enabled, you can restore to * any point in time within 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. *

You can call DescribeContinuousBackups at a maximum rate of * 10 times per second.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeContinuousBackupsAsync(const Model::DescribeContinuousBackupsRequest& request, const DescribeContinuousBackupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Returns information about contributor insights, for a given table or global * secondary index.

See Also:

AWS * API Reference

*/ virtual Model::DescribeContributorInsightsOutcome DescribeContributorInsights(const Model::DescribeContributorInsightsRequest& request) const; /** *

Returns information about contributor insights, for a given table or global * secondary index.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeContributorInsightsOutcomeCallable DescribeContributorInsightsCallable(const Model::DescribeContributorInsightsRequest& request) const; /** *

Returns information about contributor insights, for a given table or global * secondary index.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeContributorInsightsAsync(const Model::DescribeContributorInsightsRequest& request, const DescribeContributorInsightsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Returns the regional endpoint information.

See Also:

AWS * API Reference

*/ virtual Model::DescribeEndpointsOutcome DescribeEndpoints(const Model::DescribeEndpointsRequest& request) const; /** *

Returns the regional endpoint information.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeEndpointsOutcomeCallable DescribeEndpointsCallable(const Model::DescribeEndpointsRequest& request) const; /** *

Returns the regional endpoint information.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeEndpointsAsync(const Model::DescribeEndpointsRequest& request, const DescribeEndpointsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Returns information about the specified global table.

This * operation only applies to Version * 2017.11.29 of global tables. If you are using global tables Version * 2019.11.21 you can use DescribeTable * instead.

See Also:

AWS * API Reference

*/ virtual Model::DescribeGlobalTableOutcome DescribeGlobalTable(const Model::DescribeGlobalTableRequest& request) const; /** *

Returns information about the specified global table.

This * operation only applies to Version * 2017.11.29 of global tables. If you are using global tables Version * 2019.11.21 you can use DescribeTable * instead.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeGlobalTableOutcomeCallable DescribeGlobalTableCallable(const Model::DescribeGlobalTableRequest& request) const; /** *

Returns information about the specified global table.

This * operation only applies to Version * 2017.11.29 of global tables. If you are using global tables Version * 2019.11.21 you can use DescribeTable * instead.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeGlobalTableAsync(const Model::DescribeGlobalTableRequest& request, const DescribeGlobalTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Describes Region-specific settings for a global table.

This * operation only applies to Version * 2017.11.29 of global tables.

See Also:

AWS * API Reference

*/ virtual Model::DescribeGlobalTableSettingsOutcome DescribeGlobalTableSettings(const Model::DescribeGlobalTableSettingsRequest& request) const; /** *

Describes Region-specific settings for a global table.

This * operation only applies to Version * 2017.11.29 of global tables.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeGlobalTableSettingsOutcomeCallable DescribeGlobalTableSettingsCallable(const Model::DescribeGlobalTableSettingsRequest& request) const; /** *

Describes Region-specific settings for a global table.

This * operation only applies to Version * 2017.11.29 of global tables.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeGlobalTableSettingsAsync(const Model::DescribeGlobalTableSettingsRequest& request, const DescribeGlobalTableSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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 * 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.

For example, you could use one of the * AWS SDKs to do the following:

  1. Call DescribeLimits * for a particular Region to obtain your current account limits on provisioned * capacity there.

  2. 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.

  3. Call * ListTables to obtain a list of all your DynamoDB tables.

    4. *

  4. 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.

  5. 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 doesn't 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.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLimitsOutcome DescribeLimits(const Model::DescribeLimitsRequest& request) const; /** *

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 * 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.

For example, you could use one of the * AWS SDKs to do the following:

  1. Call DescribeLimits * for a particular Region to obtain your current account limits on provisioned * capacity there.

  2. 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.

  3. Call * ListTables to obtain a list of all your DynamoDB tables.

    4. *

  4. 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.

  5. 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 doesn't 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.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeLimitsOutcomeCallable DescribeLimitsCallable(const Model::DescribeLimitsRequest& request) const; /** *

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 * 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.

For example, you could use one of the * AWS SDKs to do the following:

  1. Call DescribeLimits * for a particular Region to obtain your current account limits on provisioned * capacity there.

  2. 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.

  3. Call * ListTables to obtain a list of all your DynamoDB tables.

    4. *

  4. 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.

  5. 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 doesn't 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.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeLimitsAsync(const Model::DescribeLimitsRequest& request, const DescribeLimitsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeTableOutcome DescribeTable(const Model::DescribeTableRequest& request) const; /** *

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.

See * Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeTableOutcomeCallable DescribeTableCallable(const Model::DescribeTableRequest& request) const; /** *

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.

See * Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeTableAsync(const Model::DescribeTableRequest& request, const DescribeTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Describes auto scaling settings across replicas of the global table at * once.

This operation only applies to Version * 2019.11.21 of global tables.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTableReplicaAutoScalingOutcome DescribeTableReplicaAutoScaling(const Model::DescribeTableReplicaAutoScalingRequest& request) const; /** *

Describes auto scaling settings across replicas of the global table at * once.

This operation only applies to Version * 2019.11.21 of global tables.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeTableReplicaAutoScalingOutcomeCallable DescribeTableReplicaAutoScalingCallable(const Model::DescribeTableReplicaAutoScalingRequest& request) const; /** *

Describes auto scaling settings across replicas of the global table at * once.

This operation only applies to Version * 2019.11.21 of global tables.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeTableReplicaAutoScalingAsync(const Model::DescribeTableReplicaAutoScalingRequest& request, const DescribeTableReplicaAutoScalingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Gives a description of the Time to Live (TTL) status on the specified table. *

See Also:

AWS * API Reference

*/ virtual Model::DescribeTimeToLiveOutcome DescribeTimeToLive(const Model::DescribeTimeToLiveRequest& request) const; /** *

Gives a description of the Time to Live (TTL) status on the specified table. *

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::DescribeTimeToLiveOutcomeCallable DescribeTimeToLiveCallable(const Model::DescribeTimeToLiveRequest& request) const; /** *

Gives a description of the Time to Live (TTL) status on the specified table. *

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void DescribeTimeToLiveAsync(const Model::DescribeTimeToLiveRequest& request, const DescribeTimeToLiveResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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 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.

See Also:

AWS * API Reference

*/ virtual Model::GetItemOutcome GetItem(const Model::GetItemRequest& request) const; /** *

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 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.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::GetItemOutcomeCallable GetItemCallable(const Model::GetItemRequest& request) const; /** *

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 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.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void GetItemAsync(const Model::GetItemRequest& request, const GetItemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

List backups associated with an AWS account. To list backups for a given * table, specify TableName. ListBackups returns a * paginated list of results with at most 1 MB worth of items in a page. You can * also specify a limit for the maximum number of entries to be returned in a page. *

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 ListBackups a maximum of five times * per second.

See Also:

AWS * API Reference

*/ virtual Model::ListBackupsOutcome ListBackups(const Model::ListBackupsRequest& request) const; /** *

List backups associated with an AWS account. To list backups for a given * table, specify TableName. ListBackups returns a * paginated list of results with at most 1 MB worth of items in a page. You can * also specify a limit for the maximum number of entries to be returned in a page. *

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 ListBackups a maximum of five times * per second.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::ListBackupsOutcomeCallable ListBackupsCallable(const Model::ListBackupsRequest& request) const; /** *

List backups associated with an AWS account. To list backups for a given * table, specify TableName. ListBackups returns a * paginated list of results with at most 1 MB worth of items in a page. You can * also specify a limit for the maximum number of entries to be returned in a page. *

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 ListBackups a maximum of five times * per second.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void ListBackupsAsync(const Model::ListBackupsRequest& request, const ListBackupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Returns a list of ContributorInsightsSummary for a table and all its global * secondary indexes.

See Also:

AWS * API Reference

*/ virtual Model::ListContributorInsightsOutcome ListContributorInsights(const Model::ListContributorInsightsRequest& request) const; /** *

Returns a list of ContributorInsightsSummary for a table and all its global * secondary indexes.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::ListContributorInsightsOutcomeCallable ListContributorInsightsCallable(const Model::ListContributorInsightsRequest& request) const; /** *

Returns a list of ContributorInsightsSummary for a table and all its global * secondary indexes.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void ListContributorInsightsAsync(const Model::ListContributorInsightsRequest& request, const ListContributorInsightsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Lists all global tables that have a replica in the specified Region.

*

This operation only applies to Version * 2017.11.29 of global tables.

See Also:

AWS * API Reference

*/ virtual Model::ListGlobalTablesOutcome ListGlobalTables(const Model::ListGlobalTablesRequest& request) const; /** *

Lists all global tables that have a replica in the specified Region.

*

This operation only applies to Version * 2017.11.29 of global tables.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::ListGlobalTablesOutcomeCallable ListGlobalTablesCallable(const Model::ListGlobalTablesRequest& request) const; /** *

Lists all global tables that have a replica in the specified Region.

*

This operation only applies to Version * 2017.11.29 of global tables.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void ListGlobalTablesAsync(const Model::ListGlobalTablesRequest& request, const ListGlobalTablesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::ListTablesOutcome ListTables(const Model::ListTablesRequest& request) const; /** *

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.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::ListTablesOutcomeCallable ListTablesCallable(const Model::ListTablesRequest& request) const; /** *

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.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void ListTablesAsync(const Model::ListTablesRequest& request, const ListTablesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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.

See * Also:

AWS * API Reference

*/ virtual Model::ListTagsOfResourceOutcome ListTagsOfResource(const Model::ListTagsOfResourceRequest& request) const; /** *

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.

See * Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::ListTagsOfResourceOutcomeCallable ListTagsOfResourceCallable(const Model::ListTagsOfResourceRequest& request) const; /** *

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.

See * Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void ListTagsOfResourceAsync(const Model::ListTagsOfResourceRequest& request, const ListTagsOfResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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 * ReturnValues parameter.

This topic provides * general information about the PutItem API.

For information * on how to call the PutItem API using the AWS SDK in specific * languages, see the following:

When you * add an item, the primary key attributes are the only required attributes. * Attribute values cannot be null.

Empty String and Binary attribute values * are allowed. Attribute values of type String and Binary must have a length * greater than zero if the attribute is used as a key attribute for a table or * index. Set type attributes cannot be empty.

Invalid Requests with empty * values will be rejected with a ValidationException exception.

*

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 PutItem, see Working * with Items in the Amazon DynamoDB Developer Guide.

See * Also:

AWS * API Reference

*/ virtual Model::PutItemOutcome PutItem(const Model::PutItemRequest& request) const; /** *

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 * ReturnValues parameter.

This topic provides * general information about the PutItem API.

For information * on how to call the PutItem API using the AWS SDK in specific * languages, see the following:

When you * add an item, the primary key attributes are the only required attributes. * Attribute values cannot be null.

Empty String and Binary attribute values * are allowed. Attribute values of type String and Binary must have a length * greater than zero if the attribute is used as a key attribute for a table or * index. Set type attributes cannot be empty.

Invalid Requests with empty * values will be rejected with a ValidationException exception.

*

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 PutItem, see Working * with Items in the Amazon DynamoDB Developer Guide.

See * Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::PutItemOutcomeCallable PutItemCallable(const Model::PutItemRequest& request) const; /** *

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 * ReturnValues parameter.

This topic provides * general information about the PutItem API.

For information * on how to call the PutItem API using the AWS SDK in specific * languages, see the following:

When you * add an item, the primary key attributes are the only required attributes. * Attribute values cannot be null.

Empty String and Binary attribute values * are allowed. Attribute values of type String and Binary must have a length * greater than zero if the attribute is used as a key attribute for a table or * index. Set type attributes cannot be empty.

Invalid Requests with empty * values will be rejected with a ValidationException exception.

*

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 PutItem, see Working * with Items in the Amazon DynamoDB Developer Guide.

See * Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void PutItemAsync(const Model::PutItemRequest& request, const PutItemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

The 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).

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. 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.

A 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.

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 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.

A single * 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.

A * Query operation can return an empty result set and a * LastEvaluatedKey if all the items read for the page of results are * filtered out.

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.

See Also:

AWS API * Reference

*/ virtual Model::QueryOutcome Query(const Model::QueryRequest& request) const; /** *

The 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).

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. 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.

A 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.

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 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.

A single * 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.

A * Query operation can return an empty result set and a * LastEvaluatedKey if all the items read for the page of results are * filtered out.

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.

See Also:

AWS API * Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::QueryOutcomeCallable QueryCallable(const Model::QueryRequest& request) const; /** *

The 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).

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. 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.

A 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.

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 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.

A single * 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.

A * Query operation can return an empty result set and a * LastEvaluatedKey if all the items read for the page of results are * filtered out.

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.

See Also:

AWS API * Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void QueryAsync(const Model::QueryRequest& request, const QueryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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 RestoreTableFromBackup at a maximum rate of 10 * times per second.

You must manually set up the following on the restored * table:

  • Auto scaling policies

  • IAM policies

    *

  • Amazon CloudWatch metrics and alarms

  • Tags

    *

  • Stream settings

  • Time to Live (TTL) settings

    *

See Also:

AWS * API Reference

*/ virtual Model::RestoreTableFromBackupOutcome RestoreTableFromBackup(const Model::RestoreTableFromBackupRequest& request) const; /** *

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 RestoreTableFromBackup at a maximum rate of 10 * times per second.

You must manually set up the following on the restored * table:

  • Auto scaling policies

  • IAM policies

    *

  • Amazon CloudWatch metrics and alarms

  • Tags

    *

  • Stream settings

  • Time to Live (TTL) settings

    *

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::RestoreTableFromBackupOutcomeCallable RestoreTableFromBackupCallable(const Model::RestoreTableFromBackupRequest& request) const; /** *

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 RestoreTableFromBackup at a maximum rate of 10 * times per second.

You must manually set up the following on the restored * table:

  • Auto scaling policies

  • IAM policies

    *

  • Amazon CloudWatch metrics and alarms

  • Tags

    *

  • Stream settings

  • Time to Live (TTL) settings

    *

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void RestoreTableFromBackupAsync(const Model::RestoreTableFromBackupRequest& request, const RestoreTableFromBackupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Restores the specified table to the specified point in time within * EarliestRestorableDateTime 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.

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

  • Amazon CloudWatch * metrics and alarms

  • Tags

  • Stream settings

    *

  • Time to Live (TTL) settings

  • Point in time * recovery settings

See Also:

AWS * API Reference

*/ virtual Model::RestoreTableToPointInTimeOutcome RestoreTableToPointInTime(const Model::RestoreTableToPointInTimeRequest& request) const; /** *

Restores the specified table to the specified point in time within * EarliestRestorableDateTime 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.

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

  • Amazon CloudWatch * metrics and alarms

  • Tags

  • Stream settings

    *

  • Time to Live (TTL) settings

  • Point in time * recovery settings

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::RestoreTableToPointInTimeOutcomeCallable RestoreTableToPointInTimeCallable(const Model::RestoreTableToPointInTimeRequest& request) const; /** *

Restores the specified table to the specified point in time within * EarliestRestorableDateTime 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.

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

  • Amazon CloudWatch * metrics and alarms

  • Tags

  • Stream settings

    *

  • Time to Live (TTL) settings

  • Point in time * recovery settings

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void RestoreTableToPointInTimeAsync(const Model::RestoreTableToPointInTimeRequest& request, const RestoreTableToPointInTimeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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 FilterExpression operation.

*

If the total number of scanned items exceeds the maximum dataset 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.

A single * Scan operation reads 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 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.

See * Also:

AWS API * Reference

*/ virtual Model::ScanOutcome Scan(const Model::ScanRequest& request) const; /** *

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 FilterExpression operation.

*

If the total number of scanned items exceeds the maximum dataset 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.

A single * Scan operation reads 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 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.

See * Also:

AWS API * Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::ScanOutcomeCallable ScanCallable(const Model::ScanRequest& request) const; /** *

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 FilterExpression operation.

*

If the total number of scanned items exceeds the maximum dataset 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.

A single * Scan operation reads 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 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.

See * Also:

AWS API * Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void ScanAsync(const Model::ScanRequest& request, const ScanResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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 * five times per second, per account.

For an overview on tagging DynamoDB * resources, see Tagging * for DynamoDB in the Amazon DynamoDB Developer Guide.

See * Also:

AWS * API Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** *

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 * five times per second, per account.

For an overview on tagging DynamoDB * resources, see Tagging * for DynamoDB in the Amazon DynamoDB Developer Guide.

See * Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::TagResourceOutcomeCallable TagResourceCallable(const Model::TagResourceRequest& request) const; /** *

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 * five times per second, per account.

For an overview on tagging DynamoDB * resources, see Tagging * for DynamoDB in the Amazon DynamoDB Developer Guide.

See * Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void TagResourceAsync(const Model::TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

TransactGetItems is a synchronous operation that atomically * retrieves multiple items from one or more tables (but not from indexes) in a * single account and Region. A TransactGetItems call can contain up * to 25 TransactGetItem objects, each of which contains a * Get structure that specifies an item to retrieve from a table in * the account and Region. A call to TransactGetItems cannot retrieve * items from tables in more than one AWS account or Region. The aggregate size of * the items in the transaction cannot exceed 4 MB.

DynamoDB rejects the * entire TransactGetItems request if any of the following is * true:

  • A conflicting operation is in the process of updating an * item to be read.

  • There is insufficient provisioned capacity * for the transaction to be completed.

  • There is a user error, * such as an invalid data format.

  • The aggregate size of the * items in the transaction cannot exceed 4 MB.

See * Also:

AWS * API Reference

*/ virtual Model::TransactGetItemsOutcome TransactGetItems(const Model::TransactGetItemsRequest& request) const; /** *

TransactGetItems is a synchronous operation that atomically * retrieves multiple items from one or more tables (but not from indexes) in a * single account and Region. A TransactGetItems call can contain up * to 25 TransactGetItem objects, each of which contains a * Get structure that specifies an item to retrieve from a table in * the account and Region. A call to TransactGetItems cannot retrieve * items from tables in more than one AWS account or Region. The aggregate size of * the items in the transaction cannot exceed 4 MB.

DynamoDB rejects the * entire TransactGetItems request if any of the following is * true:

  • A conflicting operation is in the process of updating an * item to be read.

  • There is insufficient provisioned capacity * for the transaction to be completed.

  • There is a user error, * such as an invalid data format.

  • The aggregate size of the * items in the transaction cannot exceed 4 MB.

See * Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::TransactGetItemsOutcomeCallable TransactGetItemsCallable(const Model::TransactGetItemsRequest& request) const; /** *

TransactGetItems is a synchronous operation that atomically * retrieves multiple items from one or more tables (but not from indexes) in a * single account and Region. A TransactGetItems call can contain up * to 25 TransactGetItem objects, each of which contains a * Get structure that specifies an item to retrieve from a table in * the account and Region. A call to TransactGetItems cannot retrieve * items from tables in more than one AWS account or Region. The aggregate size of * the items in the transaction cannot exceed 4 MB.

DynamoDB rejects the * entire TransactGetItems request if any of the following is * true:

  • A conflicting operation is in the process of updating an * item to be read.

  • There is insufficient provisioned capacity * for the transaction to be completed.

  • There is a user error, * such as an invalid data format.

  • The aggregate size of the * items in the transaction cannot exceed 4 MB.

See * Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void TransactGetItemsAsync(const Model::TransactGetItemsRequest& request, const TransactGetItemsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

TransactWriteItems is a synchronous write operation that groups * up to 25 action requests. These actions can target items in different tables, * but not in different AWS accounts or Regions, and no two actions can target the * same item. For example, you cannot both ConditionCheck and * Update the same item. The aggregate size of the items in the * transaction cannot exceed 4 MB.

The actions are completed atomically so * that either all of them succeed, or all of them fail. They are defined by the * following objects:

  • Put  —   Initiates a * PutItem operation to write a new item. This structure specifies the * primary key of the item to be written, the name of the table to write it in, an * optional condition expression that must be satisfied for the write to succeed, a * list of the item's attributes, and a field indicating whether to retrieve the * item's attributes if the condition is not met.

  • * Update  —   Initiates an UpdateItem operation to * update an existing item. This structure specifies the primary key of the item to * be updated, the name of the table where it resides, an optional condition * expression that must be satisfied for the update to succeed, an expression that * defines one or more attributes to be updated, and a field indicating whether to * retrieve the item's attributes if the condition is not met.

  • * Delete  —   Initiates a DeleteItem operation to * delete an existing item. This structure specifies the primary key of the item to * be deleted, the name of the table where it resides, an optional condition * expression that must be satisfied for the deletion to succeed, and a field * indicating whether to retrieve the item's attributes if the condition is not * met.

  • ConditionCheck  —   Applies a * condition to an item that is not being modified by the transaction. This * structure specifies the primary key of the item to be checked, the name of the * table where it resides, a condition expression that must be satisfied for the * transaction to succeed, and a field indicating whether to retrieve the item's * attributes if the condition is not met.

DynamoDB rejects the * entire TransactWriteItems request if any of the following is * true:

  • A condition in one of the condition expressions is not * met.

  • An ongoing operation is in the process of updating the * same item.

  • There is insufficient provisioned capacity for the * transaction to be completed.

  • An item size becomes too large * (bigger than 400 KB), a local secondary index (LSI) becomes too large, or a * similar validation error occurs because of changes made by the transaction.

    *

  • The aggregate size of the items in the transaction exceeds 4 * MB.

  • There is a user error, such as an invalid data format.

    *

See Also:

AWS * API Reference

*/ virtual Model::TransactWriteItemsOutcome TransactWriteItems(const Model::TransactWriteItemsRequest& request) const; /** *

TransactWriteItems is a synchronous write operation that groups * up to 25 action requests. These actions can target items in different tables, * but not in different AWS accounts or Regions, and no two actions can target the * same item. For example, you cannot both ConditionCheck and * Update the same item. The aggregate size of the items in the * transaction cannot exceed 4 MB.

The actions are completed atomically so * that either all of them succeed, or all of them fail. They are defined by the * following objects:

  • Put  —   Initiates a * PutItem operation to write a new item. This structure specifies the * primary key of the item to be written, the name of the table to write it in, an * optional condition expression that must be satisfied for the write to succeed, a * list of the item's attributes, and a field indicating whether to retrieve the * item's attributes if the condition is not met.

  • * Update  —   Initiates an UpdateItem operation to * update an existing item. This structure specifies the primary key of the item to * be updated, the name of the table where it resides, an optional condition * expression that must be satisfied for the update to succeed, an expression that * defines one or more attributes to be updated, and a field indicating whether to * retrieve the item's attributes if the condition is not met.

  • * Delete  —   Initiates a DeleteItem operation to * delete an existing item. This structure specifies the primary key of the item to * be deleted, the name of the table where it resides, an optional condition * expression that must be satisfied for the deletion to succeed, and a field * indicating whether to retrieve the item's attributes if the condition is not * met.

  • ConditionCheck  —   Applies a * condition to an item that is not being modified by the transaction. This * structure specifies the primary key of the item to be checked, the name of the * table where it resides, a condition expression that must be satisfied for the * transaction to succeed, and a field indicating whether to retrieve the item's * attributes if the condition is not met.

DynamoDB rejects the * entire TransactWriteItems request if any of the following is * true:

  • A condition in one of the condition expressions is not * met.

  • An ongoing operation is in the process of updating the * same item.

  • There is insufficient provisioned capacity for the * transaction to be completed.

  • An item size becomes too large * (bigger than 400 KB), a local secondary index (LSI) becomes too large, or a * similar validation error occurs because of changes made by the transaction.

    *

  • The aggregate size of the items in the transaction exceeds 4 * MB.

  • There is a user error, such as an invalid data format.

    *

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::TransactWriteItemsOutcomeCallable TransactWriteItemsCallable(const Model::TransactWriteItemsRequest& request) const; /** *

TransactWriteItems is a synchronous write operation that groups * up to 25 action requests. These actions can target items in different tables, * but not in different AWS accounts or Regions, and no two actions can target the * same item. For example, you cannot both ConditionCheck and * Update the same item. The aggregate size of the items in the * transaction cannot exceed 4 MB.

The actions are completed atomically so * that either all of them succeed, or all of them fail. They are defined by the * following objects:

  • Put  —   Initiates a * PutItem operation to write a new item. This structure specifies the * primary key of the item to be written, the name of the table to write it in, an * optional condition expression that must be satisfied for the write to succeed, a * list of the item's attributes, and a field indicating whether to retrieve the * item's attributes if the condition is not met.

  • * Update  —   Initiates an UpdateItem operation to * update an existing item. This structure specifies the primary key of the item to * be updated, the name of the table where it resides, an optional condition * expression that must be satisfied for the update to succeed, an expression that * defines one or more attributes to be updated, and a field indicating whether to * retrieve the item's attributes if the condition is not met.

  • * Delete  —   Initiates a DeleteItem operation to * delete an existing item. This structure specifies the primary key of the item to * be deleted, the name of the table where it resides, an optional condition * expression that must be satisfied for the deletion to succeed, and a field * indicating whether to retrieve the item's attributes if the condition is not * met.

  • ConditionCheck  —   Applies a * condition to an item that is not being modified by the transaction. This * structure specifies the primary key of the item to be checked, the name of the * table where it resides, a condition expression that must be satisfied for the * transaction to succeed, and a field indicating whether to retrieve the item's * attributes if the condition is not met.

DynamoDB rejects the * entire TransactWriteItems request if any of the following is * true:

  • A condition in one of the condition expressions is not * met.

  • An ongoing operation is in the process of updating the * same item.

  • There is insufficient provisioned capacity for the * transaction to be completed.

  • An item size becomes too large * (bigger than 400 KB), a local secondary index (LSI) becomes too large, or a * similar validation error occurs because of changes made by the transaction.

    *

  • The aggregate size of the items in the transaction exceeds 4 * MB.

  • There is a user error, such as an invalid data format.

    *

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void TransactWriteItemsAsync(const Model::TransactWriteItemsRequest& request, const TransactWriteItemsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Removes the association of tags from an Amazon DynamoDB resource. You can * call UntagResource up to five times per second, per account.

*

For an overview on tagging DynamoDB resources, see Tagging * for DynamoDB in the Amazon DynamoDB Developer Guide.

See * Also:

AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** *

Removes the association of tags from an Amazon DynamoDB resource. You can * call UntagResource up to five times per second, per account.

*

For an overview on tagging DynamoDB resources, see Tagging * for DynamoDB in the Amazon DynamoDB Developer Guide.

See * Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::UntagResourceOutcomeCallable UntagResourceCallable(const Model::UntagResourceRequest& request) const; /** *

Removes the association of tags from an Amazon DynamoDB resource. You can * call UntagResource up to five times per second, per account.

*

For an overview on tagging DynamoDB resources, see Tagging * for DynamoDB in the Amazon DynamoDB Developer Guide.

See * Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void UntagResourceAsync(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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.

*

Once continuous backups and point in time recovery are enabled, you can * restore to any point in time within 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. *

See Also:

AWS * API Reference

*/ virtual Model::UpdateContinuousBackupsOutcome UpdateContinuousBackups(const Model::UpdateContinuousBackupsRequest& request) const; /** *

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.

*

Once continuous backups and point in time recovery are enabled, you can * restore to any point in time within 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. *

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::UpdateContinuousBackupsOutcomeCallable UpdateContinuousBackupsCallable(const Model::UpdateContinuousBackupsRequest& request) const; /** *

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.

*

Once continuous backups and point in time recovery are enabled, you can * restore to any point in time within 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. *

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void UpdateContinuousBackupsAsync(const Model::UpdateContinuousBackupsRequest& request, const UpdateContinuousBackupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Updates the status for contributor insights for a specific table or * index.

See Also:

AWS * API Reference

*/ virtual Model::UpdateContributorInsightsOutcome UpdateContributorInsights(const Model::UpdateContributorInsightsRequest& request) const; /** *

Updates the status for contributor insights for a specific table or * index.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::UpdateContributorInsightsOutcomeCallable UpdateContributorInsightsCallable(const Model::UpdateContributorInsightsRequest& request) const; /** *

Updates the status for contributor insights for a specific table or * index.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void UpdateContributorInsightsAsync(const Model::UpdateContributorInsightsRequest& request, const UpdateContributorInsightsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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, have the same name as the global table, have the same key schema, have * DynamoDB Streams enabled, and have the same provisioned and maximum write * capacity units.

Although you can use * 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.

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.

See Also:

AWS * API Reference

*/ virtual Model::UpdateGlobalTableOutcome UpdateGlobalTable(const Model::UpdateGlobalTableRequest& request) const; /** *

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, have the same name as the global table, have the same key schema, have * DynamoDB Streams enabled, and have the same provisioned and maximum write * capacity units.

Although you can use * 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.

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.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::UpdateGlobalTableOutcomeCallable UpdateGlobalTableCallable(const Model::UpdateGlobalTableRequest& request) const; /** *

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, have the same name as the global table, have the same key schema, have * DynamoDB Streams enabled, and have the same provisioned and maximum write * capacity units.

Although you can use * 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.

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.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void UpdateGlobalTableAsync(const Model::UpdateGlobalTableRequest& request, const UpdateGlobalTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Updates settings for a global table.

See Also:

AWS * API Reference

*/ virtual Model::UpdateGlobalTableSettingsOutcome UpdateGlobalTableSettings(const Model::UpdateGlobalTableSettingsRequest& request) const; /** *

Updates settings for a global table.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::UpdateGlobalTableSettingsOutcomeCallable UpdateGlobalTableSettingsCallable(const Model::UpdateGlobalTableSettingsRequest& request) const; /** *

Updates settings for a global table.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void UpdateGlobalTableSettingsAsync(const Model::UpdateGlobalTableSettingsRequest& request, const UpdateGlobalTableSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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.

See Also:

AWS * API Reference

*/ virtual Model::UpdateItemOutcome UpdateItem(const Model::UpdateItemRequest& request) const; /** *

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.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::UpdateItemOutcomeCallable UpdateItemCallable(const Model::UpdateItemRequest& request) const; /** *

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.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void UpdateItemAsync(const Model::UpdateItemRequest& request, const UpdateItemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

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 DynamoDB * Streams on the table.

  • Remove a global secondary index from the * table.

  • Create a new global secondary index on the table. After * 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.

See Also:

AWS * API Reference

*/ virtual Model::UpdateTableOutcome UpdateTable(const Model::UpdateTableRequest& request) const; /** *

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 DynamoDB * Streams on the table.

  • Remove a global secondary index from the * table.

  • Create a new global secondary index on the table. After * 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.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::UpdateTableOutcomeCallable UpdateTableCallable(const Model::UpdateTableRequest& request) const; /** *

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 DynamoDB * Streams on the table.

  • Remove a global secondary index from the * table.

  • Create a new global secondary index on the table. After * 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.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void UpdateTableAsync(const Model::UpdateTableRequest& request, const UpdateTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

Updates auto scaling settings on your global tables at once.

*

This operation only applies to Version * 2019.11.21 of global tables.

See Also:

AWS * API Reference

*/ virtual Model::UpdateTableReplicaAutoScalingOutcome UpdateTableReplicaAutoScaling(const Model::UpdateTableReplicaAutoScalingRequest& request) const; /** *

Updates auto scaling settings on your global tables at once.

*

This operation only applies to Version * 2019.11.21 of global tables.

See Also:

AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::UpdateTableReplicaAutoScalingOutcomeCallable UpdateTableReplicaAutoScalingCallable(const Model::UpdateTableReplicaAutoScalingRequest& request) const; /** *

Updates auto scaling settings on your global tables at once.

*

This operation only applies to Version * 2019.11.21 of global tables.

See Also:

AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void UpdateTableReplicaAutoScalingAsync(const Model::UpdateTableReplicaAutoScalingRequest& request, const UpdateTableReplicaAutoScalingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; /** *

The UpdateTimeToLive method enables or disables Time to Live * (TTL) for the specified table. A successful UpdateTimeToLive call * returns the current TimeToLiveSpecification. It can 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.

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 1, * 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.

See Also:

* AWS * API Reference

*/ virtual Model::UpdateTimeToLiveOutcome UpdateTimeToLive(const Model::UpdateTimeToLiveRequest& request) const; /** *

The UpdateTimeToLive method enables or disables Time to Live * (TTL) for the specified table. A successful UpdateTimeToLive call * returns the current TimeToLiveSpecification. It can 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.

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 1, * 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.

See Also:

* AWS * API Reference

* * returns a future to the operation so that it can be executed in parallel to other requests. */ virtual Model::UpdateTimeToLiveOutcomeCallable UpdateTimeToLiveCallable(const Model::UpdateTimeToLiveRequest& request) const; /** *

The UpdateTimeToLive method enables or disables Time to Live * (TTL) for the specified table. A successful UpdateTimeToLive call * returns the current TimeToLiveSpecification. It can 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.

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 1, * 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.

See Also:

* AWS * API Reference

* * Queues the request into a thread executor and triggers associated callback when operation has finished. */ virtual void UpdateTimeToLiveAsync(const Model::UpdateTimeToLiveRequest& request, const UpdateTimeToLiveResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const; void OverrideEndpoint(const Aws::String& endpoint); private: void init(const Aws::Client::ClientConfiguration& clientConfiguration); void BatchGetItemAsyncHelper(const Model::BatchGetItemRequest& request, const BatchGetItemResponseReceivedHandler& handler, const std::shared_ptr& context) const; void BatchWriteItemAsyncHelper(const Model::BatchWriteItemRequest& request, const BatchWriteItemResponseReceivedHandler& handler, const std::shared_ptr& context) const; void CreateBackupAsyncHelper(const Model::CreateBackupRequest& request, const CreateBackupResponseReceivedHandler& handler, const std::shared_ptr& context) const; void CreateGlobalTableAsyncHelper(const Model::CreateGlobalTableRequest& request, const CreateGlobalTableResponseReceivedHandler& handler, const std::shared_ptr& context) const; void CreateTableAsyncHelper(const Model::CreateTableRequest& request, const CreateTableResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DeleteBackupAsyncHelper(const Model::DeleteBackupRequest& request, const DeleteBackupResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DeleteItemAsyncHelper(const Model::DeleteItemRequest& request, const DeleteItemResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DeleteTableAsyncHelper(const Model::DeleteTableRequest& request, const DeleteTableResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeBackupAsyncHelper(const Model::DescribeBackupRequest& request, const DescribeBackupResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeContinuousBackupsAsyncHelper(const Model::DescribeContinuousBackupsRequest& request, const DescribeContinuousBackupsResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeContributorInsightsAsyncHelper(const Model::DescribeContributorInsightsRequest& request, const DescribeContributorInsightsResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeEndpointsAsyncHelper(const Model::DescribeEndpointsRequest& request, const DescribeEndpointsResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeGlobalTableAsyncHelper(const Model::DescribeGlobalTableRequest& request, const DescribeGlobalTableResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeGlobalTableSettingsAsyncHelper(const Model::DescribeGlobalTableSettingsRequest& request, const DescribeGlobalTableSettingsResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeLimitsAsyncHelper(const Model::DescribeLimitsRequest& request, const DescribeLimitsResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeTableAsyncHelper(const Model::DescribeTableRequest& request, const DescribeTableResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeTableReplicaAutoScalingAsyncHelper(const Model::DescribeTableReplicaAutoScalingRequest& request, const DescribeTableReplicaAutoScalingResponseReceivedHandler& handler, const std::shared_ptr& context) const; void DescribeTimeToLiveAsyncHelper(const Model::DescribeTimeToLiveRequest& request, const DescribeTimeToLiveResponseReceivedHandler& handler, const std::shared_ptr& context) const; void GetItemAsyncHelper(const Model::GetItemRequest& request, const GetItemResponseReceivedHandler& handler, const std::shared_ptr& context) const; void ListBackupsAsyncHelper(const Model::ListBackupsRequest& request, const ListBackupsResponseReceivedHandler& handler, const std::shared_ptr& context) const; void ListContributorInsightsAsyncHelper(const Model::ListContributorInsightsRequest& request, const ListContributorInsightsResponseReceivedHandler& handler, const std::shared_ptr& context) const; void ListGlobalTablesAsyncHelper(const Model::ListGlobalTablesRequest& request, const ListGlobalTablesResponseReceivedHandler& handler, const std::shared_ptr& context) const; void ListTablesAsyncHelper(const Model::ListTablesRequest& request, const ListTablesResponseReceivedHandler& handler, const std::shared_ptr& context) const; void ListTagsOfResourceAsyncHelper(const Model::ListTagsOfResourceRequest& request, const ListTagsOfResourceResponseReceivedHandler& handler, const std::shared_ptr& context) const; void PutItemAsyncHelper(const Model::PutItemRequest& request, const PutItemResponseReceivedHandler& handler, const std::shared_ptr& context) const; void QueryAsyncHelper(const Model::QueryRequest& request, const QueryResponseReceivedHandler& handler, const std::shared_ptr& context) const; void RestoreTableFromBackupAsyncHelper(const Model::RestoreTableFromBackupRequest& request, const RestoreTableFromBackupResponseReceivedHandler& handler, const std::shared_ptr& context) const; void RestoreTableToPointInTimeAsyncHelper(const Model::RestoreTableToPointInTimeRequest& request, const RestoreTableToPointInTimeResponseReceivedHandler& handler, const std::shared_ptr& context) const; void ScanAsyncHelper(const Model::ScanRequest& request, const ScanResponseReceivedHandler& handler, const std::shared_ptr& context) const; void TagResourceAsyncHelper(const Model::TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context) const; void TransactGetItemsAsyncHelper(const Model::TransactGetItemsRequest& request, const TransactGetItemsResponseReceivedHandler& handler, const std::shared_ptr& context) const; void TransactWriteItemsAsyncHelper(const Model::TransactWriteItemsRequest& request, const TransactWriteItemsResponseReceivedHandler& handler, const std::shared_ptr& context) const; void UntagResourceAsyncHelper(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context) const; void UpdateContinuousBackupsAsyncHelper(const Model::UpdateContinuousBackupsRequest& request, const UpdateContinuousBackupsResponseReceivedHandler& handler, const std::shared_ptr& context) const; void UpdateContributorInsightsAsyncHelper(const Model::UpdateContributorInsightsRequest& request, const UpdateContributorInsightsResponseReceivedHandler& handler, const std::shared_ptr& context) const; void UpdateGlobalTableAsyncHelper(const Model::UpdateGlobalTableRequest& request, const UpdateGlobalTableResponseReceivedHandler& handler, const std::shared_ptr& context) const; void UpdateGlobalTableSettingsAsyncHelper(const Model::UpdateGlobalTableSettingsRequest& request, const UpdateGlobalTableSettingsResponseReceivedHandler& handler, const std::shared_ptr& context) const; void UpdateItemAsyncHelper(const Model::UpdateItemRequest& request, const UpdateItemResponseReceivedHandler& handler, const std::shared_ptr& context) const; void UpdateTableAsyncHelper(const Model::UpdateTableRequest& request, const UpdateTableResponseReceivedHandler& handler, const std::shared_ptr& context) const; void UpdateTableReplicaAutoScalingAsyncHelper(const Model::UpdateTableReplicaAutoScalingRequest& request, const UpdateTableReplicaAutoScalingResponseReceivedHandler& handler, const std::shared_ptr& context) const; void UpdateTimeToLiveAsyncHelper(const Model::UpdateTimeToLiveRequest& request, const UpdateTimeToLiveResponseReceivedHandler& handler, const std::shared_ptr& context) const; Aws::String m_uri; mutable Aws::Utils::ConcurrentCache m_endpointsCache; bool m_enableEndpointDiscovery; Aws::String m_configScheme; std::shared_ptr m_executor; }; } // namespace DynamoDB } // namespace Aws