/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace DynamoDB { /** * 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 Amazon Web Services 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 Amazon Web Services Region, providing built-in high availability and * data durability.

*/ class AWS_DYNAMODB_API DynamoDBClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef DynamoDBClientConfiguration ClientConfigurationType; typedef DynamoDBEndpointProvider EndpointProviderType; /** * 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::DynamoDB::DynamoDBClientConfiguration& clientConfiguration = Aws::DynamoDB::DynamoDBClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * 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, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::DynamoDB::DynamoDBClientConfiguration& clientConfiguration = Aws::DynamoDB::DynamoDBClientConfiguration()); /** * 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, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::DynamoDB::DynamoDBClientConfiguration& clientConfiguration = Aws::DynamoDB::DynamoDBClientConfiguration()); /* Legacy constructors due deprecation */ /** * 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); /** * 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); /** * 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); /* End of legacy constructors due deprecation */ virtual ~DynamoDBClient(); /** *

This operation allows you to perform batch reads or writes on data stored in * DynamoDB, using PartiQL. Each read statement in a * BatchExecuteStatement must specify an equality condition on all key * attributes. This enforces that each SELECT statement in a batch * returns at most a single item.

The entire batch must consist of * either read statements or write statements, you cannot mix both in one * batch.

A HTTP 200 response does not mean that all * statements in the BatchExecuteStatement succeeded. Error details for individual * statements can be found under the Error * field of the BatchStatementResponse for each statement.

*

See Also:

AWS * API Reference

*/ virtual Model::BatchExecuteStatementOutcome BatchExecuteStatement(const Model::BatchExecuteStatementRequest& request) const; /** * A Callable wrapper for BatchExecuteStatement that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchExecuteStatementOutcomeCallable BatchExecuteStatementCallable(const BatchExecuteStatementRequestT& request) const { return SubmitCallable(&DynamoDBClient::BatchExecuteStatement, request); } /** * An Async wrapper for BatchExecuteStatement that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchExecuteStatementAsync(const BatchExecuteStatementRequestT& request, const BatchExecuteStatementResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::BatchExecuteStatement, request, handler, context); } /** *

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, * more than 1MB per partition is requested, 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 may retrieve 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; /** * A Callable wrapper for BatchGetItem that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchGetItemOutcomeCallable BatchGetItemCallable(const BatchGetItemRequestT& request) const { return SubmitCallable(&DynamoDBClient::BatchGetItem, request); } /** * An Async wrapper for BatchGetItem that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchGetItemAsync(const BatchGetItemRequestT& request, const BatchGetItemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::BatchGetItem, request, handler, context); } /** *

The BatchWriteItem operation puts or deletes multiple items in * one or more tables. A single call to BatchWriteItem can transmit up * to 16MB of data over the network, consisting of up to 25 item put or delete * operations. While individual items can be up to 400 KB once stored, it's * important to note that an item's representation might be greater than 400KB * while being sent in DynamoDB's JSON format for the API call. For more details on * this distinction, see Naming * Rules and Data Types.

BatchWriteItem cannot * update items. If you perform a BatchWriteItem operation on an * existing item, that item's values will be overwritten by the operation and it * will appear like it was updated. To update items, we recommend you 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; /** * A Callable wrapper for BatchWriteItem that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchWriteItemOutcomeCallable BatchWriteItemCallable(const BatchWriteItemRequestT& request) const { return SubmitCallable(&DynamoDBClient::BatchWriteItem, request); } /** * An Async wrapper for BatchWriteItem that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchWriteItemAsync(const BatchWriteItemRequestT& request, const BatchWriteItemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::BatchWriteItem, request, handler, context); } /** *

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; /** * A Callable wrapper for CreateBackup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateBackupOutcomeCallable CreateBackupCallable(const CreateBackupRequestT& request) const { return SubmitCallable(&DynamoDBClient::CreateBackup, request); } /** * An Async wrapper for CreateBackup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateBackupAsync(const CreateBackupRequestT& request, const CreateBackupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::CreateBackup, request, handler, context); } /** *

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 (Legacy) of global tables. We recommend using Version * 2019.11.21 (Current) when creating new global tables, as it provides greater * flexibility, higher efficiency and consumes less write capacity than 2017.11.29 * (Legacy). To determine which version you are using, see Determining * the version. To update existing global tables from version 2017.11.29 * (Legacy) to version 2019.11.21 (Current), see * Updating 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; /** * A Callable wrapper for CreateGlobalTable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateGlobalTableOutcomeCallable CreateGlobalTableCallable(const CreateGlobalTableRequestT& request) const { return SubmitCallable(&DynamoDBClient::CreateGlobalTable, request); } /** * An Async wrapper for CreateGlobalTable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateGlobalTableAsync(const CreateGlobalTableRequestT& request, const CreateGlobalTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::CreateGlobalTable, request, handler, context); } /** *

The CreateTable operation adds a new table to your account. In * an Amazon Web Services 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; /** * A Callable wrapper for CreateTable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTableOutcomeCallable CreateTableCallable(const CreateTableRequestT& request) const { return SubmitCallable(&DynamoDBClient::CreateTable, request); } /** * An Async wrapper for CreateTable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTableAsync(const CreateTableRequestT& request, const CreateTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::CreateTable, request, handler, context); } /** *

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; /** * A Callable wrapper for DeleteBackup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBackupOutcomeCallable DeleteBackupCallable(const DeleteBackupRequestT& request) const { return SubmitCallable(&DynamoDBClient::DeleteBackup, request); } /** * An Async wrapper for DeleteBackup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBackupAsync(const DeleteBackupRequestT& request, const DeleteBackupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::DeleteBackup, request, handler, context); } /** *

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; /** * A Callable wrapper for DeleteItem that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteItemOutcomeCallable DeleteItemCallable(const DeleteItemRequestT& request) const { return SubmitCallable(&DynamoDBClient::DeleteItem, request); } /** * An Async wrapper for DeleteItem that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteItemAsync(const DeleteItemRequestT& request, const DeleteItemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::DeleteItem, request, handler, context); } /** *

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.

*

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

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; /** * A Callable wrapper for DeleteTable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTableOutcomeCallable DeleteTableCallable(const DeleteTableRequestT& request) const { return SubmitCallable(&DynamoDBClient::DeleteTable, request); } /** * An Async wrapper for DeleteTable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTableAsync(const DeleteTableRequestT& request, const DeleteTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::DeleteTable, request, handler, context); } /** *

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; /** * A Callable wrapper for DescribeBackup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeBackupOutcomeCallable DescribeBackupCallable(const DescribeBackupRequestT& request) const { return SubmitCallable(&DynamoDBClient::DescribeBackup, request); } /** * An Async wrapper for DescribeBackup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeBackupAsync(const DescribeBackupRequestT& request, const DescribeBackupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::DescribeBackup, request, handler, context); } /** *

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; /** * A Callable wrapper for DescribeContinuousBackups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeContinuousBackupsOutcomeCallable DescribeContinuousBackupsCallable(const DescribeContinuousBackupsRequestT& request) const { return SubmitCallable(&DynamoDBClient::DescribeContinuousBackups, request); } /** * An Async wrapper for DescribeContinuousBackups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeContinuousBackupsAsync(const DescribeContinuousBackupsRequestT& request, const DescribeContinuousBackupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::DescribeContinuousBackups, request, handler, context); } /** *

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; /** * A Callable wrapper for DescribeContributorInsights that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeContributorInsightsOutcomeCallable DescribeContributorInsightsCallable(const DescribeContributorInsightsRequestT& request) const { return SubmitCallable(&DynamoDBClient::DescribeContributorInsights, request); } /** * An Async wrapper for DescribeContributorInsights that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeContributorInsightsAsync(const DescribeContributorInsightsRequestT& request, const DescribeContributorInsightsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::DescribeContributorInsights, request, handler, context); } /** *

Returns the regional endpoint information. For more information on policy * permissions, please see Internetwork * traffic privacy.

See Also:

AWS * API Reference

*/ virtual Model::DescribeEndpointsOutcome DescribeEndpoints(const Model::DescribeEndpointsRequest& request) const; /** * A Callable wrapper for DescribeEndpoints that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEndpointsOutcomeCallable DescribeEndpointsCallable(const DescribeEndpointsRequestT& request) const { return SubmitCallable(&DynamoDBClient::DescribeEndpoints, request); } /** * An Async wrapper for DescribeEndpoints that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEndpointsAsync(const DescribeEndpointsRequestT& request, const DescribeEndpointsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::DescribeEndpoints, request, handler, context); } /** *

Describes an existing table export.

See Also:

AWS * API Reference

*/ virtual Model::DescribeExportOutcome DescribeExport(const Model::DescribeExportRequest& request) const; /** * A Callable wrapper for DescribeExport that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeExportOutcomeCallable DescribeExportCallable(const DescribeExportRequestT& request) const { return SubmitCallable(&DynamoDBClient::DescribeExport, request); } /** * An Async wrapper for DescribeExport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeExportAsync(const DescribeExportRequestT& request, const DescribeExportResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::DescribeExport, request, handler, context); } /** *

Returns information about the specified global table.

This * operation only applies to Version * 2017.11.29 (Legacy) of global tables. We recommend using Version * 2019.11.21 (Current) when creating new global tables, as it provides greater * flexibility, higher efficiency and consumes less write capacity than 2017.11.29 * (Legacy). To determine which version you are using, see Determining * the version. To update existing global tables from version 2017.11.29 * (Legacy) to version 2019.11.21 (Current), see * Updating global tables.

See Also:

AWS * API Reference

*/ virtual Model::DescribeGlobalTableOutcome DescribeGlobalTable(const Model::DescribeGlobalTableRequest& request) const; /** * A Callable wrapper for DescribeGlobalTable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeGlobalTableOutcomeCallable DescribeGlobalTableCallable(const DescribeGlobalTableRequestT& request) const { return SubmitCallable(&DynamoDBClient::DescribeGlobalTable, request); } /** * An Async wrapper for DescribeGlobalTable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeGlobalTableAsync(const DescribeGlobalTableRequestT& request, const DescribeGlobalTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::DescribeGlobalTable, request, handler, context); } /** *

Describes Region-specific settings for a global table.

*

This operation only applies to Version * 2017.11.29 (Legacy) of global tables. We recommend using Version * 2019.11.21 (Current) when creating new global tables, as it provides greater * flexibility, higher efficiency and consumes less write capacity than 2017.11.29 * (Legacy). To determine which version you are using, see Determining * the version. To update existing global tables from version 2017.11.29 * (Legacy) to version 2019.11.21 (Current), see * Updating global tables.

See Also:

AWS * API Reference

*/ virtual Model::DescribeGlobalTableSettingsOutcome DescribeGlobalTableSettings(const Model::DescribeGlobalTableSettingsRequest& request) const; /** * A Callable wrapper for DescribeGlobalTableSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeGlobalTableSettingsOutcomeCallable DescribeGlobalTableSettingsCallable(const DescribeGlobalTableSettingsRequestT& request) const { return SubmitCallable(&DynamoDBClient::DescribeGlobalTableSettings, request); } /** * An Async wrapper for DescribeGlobalTableSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeGlobalTableSettingsAsync(const DescribeGlobalTableSettingsRequestT& request, const DescribeGlobalTableSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::DescribeGlobalTableSettings, request, handler, context); } /** *

Represents the properties of the import.

See Also:

AWS * API Reference

*/ virtual Model::DescribeImportOutcome DescribeImport(const Model::DescribeImportRequest& request) const; /** * A Callable wrapper for DescribeImport that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeImportOutcomeCallable DescribeImportCallable(const DescribeImportRequestT& request) const { return SubmitCallable(&DynamoDBClient::DescribeImport, request); } /** * An Async wrapper for DescribeImport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeImportAsync(const DescribeImportRequestT& request, const DescribeImportResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::DescribeImport, request, handler, context); } /** *

Returns information about the status of Kinesis streaming.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeKinesisStreamingDestinationOutcome DescribeKinesisStreamingDestination(const Model::DescribeKinesisStreamingDestinationRequest& request) const; /** * A Callable wrapper for DescribeKinesisStreamingDestination that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeKinesisStreamingDestinationOutcomeCallable DescribeKinesisStreamingDestinationCallable(const DescribeKinesisStreamingDestinationRequestT& request) const { return SubmitCallable(&DynamoDBClient::DescribeKinesisStreamingDestination, request); } /** * An Async wrapper for DescribeKinesisStreamingDestination that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeKinesisStreamingDestinationAsync(const DescribeKinesisStreamingDestinationRequestT& request, const DescribeKinesisStreamingDestinationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::DescribeKinesisStreamingDestination, request, handler, context); } /** *

Returns the current provisioned-capacity quotas for your Amazon Web Services * 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 Amazon Web Services * account, the account has initial quotas 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 quotas that apply when you create a * table there. For more information, see Service, * Account, and Table Quotas page in the Amazon DynamoDB Developer * Guide.

Although you can increase these quotas by filing a case at Amazon Web Services 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 quotas imposed by your account so that you have * enough time to apply for an increase before you hit a quota.

For example, * you could use one of the Amazon Web Services SDKs to do the following:

    *

  1. Call DescribeLimits for a particular Region to obtain your * current account quotas 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. 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 quotas 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 quotas.

*

The per-table quotas 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 * quota that applies is that the aggregate provisioned capacity over all your * tables and GSIs cannot exceed either of the per-account quotas.

* 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; /** * A Callable wrapper for DescribeLimits that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLimitsOutcomeCallable DescribeLimitsCallable(const DescribeLimitsRequestT& request) const { return SubmitCallable(&DynamoDBClient::DescribeLimits, request); } /** * An Async wrapper for DescribeLimits that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLimitsAsync(const DescribeLimitsRequestT& request, const DescribeLimitsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::DescribeLimits, request, handler, context); } /** *

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.

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

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; /** * A Callable wrapper for DescribeTable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTableOutcomeCallable DescribeTableCallable(const DescribeTableRequestT& request) const { return SubmitCallable(&DynamoDBClient::DescribeTable, request); } /** * An Async wrapper for DescribeTable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTableAsync(const DescribeTableRequestT& request, const DescribeTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::DescribeTable, request, handler, context); } /** *

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

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

See Also:

* AWS * API Reference

*/ virtual Model::DescribeTableReplicaAutoScalingOutcome DescribeTableReplicaAutoScaling(const Model::DescribeTableReplicaAutoScalingRequest& request) const; /** * A Callable wrapper for DescribeTableReplicaAutoScaling that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTableReplicaAutoScalingOutcomeCallable DescribeTableReplicaAutoScalingCallable(const DescribeTableReplicaAutoScalingRequestT& request) const { return SubmitCallable(&DynamoDBClient::DescribeTableReplicaAutoScaling, request); } /** * An Async wrapper for DescribeTableReplicaAutoScaling that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTableReplicaAutoScalingAsync(const DescribeTableReplicaAutoScalingRequestT& request, const DescribeTableReplicaAutoScalingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::DescribeTableReplicaAutoScaling, request, handler, context); } /** *

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; /** * A Callable wrapper for DescribeTimeToLive that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTimeToLiveOutcomeCallable DescribeTimeToLiveCallable(const DescribeTimeToLiveRequestT& request) const { return SubmitCallable(&DynamoDBClient::DescribeTimeToLive, request); } /** * An Async wrapper for DescribeTimeToLive that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTimeToLiveAsync(const DescribeTimeToLiveRequestT& request, const DescribeTimeToLiveResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::DescribeTimeToLive, request, handler, context); } /** *

Stops replication from the DynamoDB table to the Kinesis data stream. This is * done without deleting either of the resources.

See Also:

AWS * API Reference

*/ virtual Model::DisableKinesisStreamingDestinationOutcome DisableKinesisStreamingDestination(const Model::DisableKinesisStreamingDestinationRequest& request) const; /** * A Callable wrapper for DisableKinesisStreamingDestination that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableKinesisStreamingDestinationOutcomeCallable DisableKinesisStreamingDestinationCallable(const DisableKinesisStreamingDestinationRequestT& request) const { return SubmitCallable(&DynamoDBClient::DisableKinesisStreamingDestination, request); } /** * An Async wrapper for DisableKinesisStreamingDestination that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableKinesisStreamingDestinationAsync(const DisableKinesisStreamingDestinationRequestT& request, const DisableKinesisStreamingDestinationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::DisableKinesisStreamingDestination, request, handler, context); } /** *

Starts table data replication to the specified Kinesis data stream at a * timestamp chosen during the enable workflow. If this operation doesn't return * results immediately, use DescribeKinesisStreamingDestination to check if * streaming to the Kinesis data stream is ACTIVE.

See Also:

AWS * API Reference

*/ virtual Model::EnableKinesisStreamingDestinationOutcome EnableKinesisStreamingDestination(const Model::EnableKinesisStreamingDestinationRequest& request) const; /** * A Callable wrapper for EnableKinesisStreamingDestination that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableKinesisStreamingDestinationOutcomeCallable EnableKinesisStreamingDestinationCallable(const EnableKinesisStreamingDestinationRequestT& request) const { return SubmitCallable(&DynamoDBClient::EnableKinesisStreamingDestination, request); } /** * An Async wrapper for EnableKinesisStreamingDestination that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableKinesisStreamingDestinationAsync(const EnableKinesisStreamingDestinationRequestT& request, const EnableKinesisStreamingDestinationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::EnableKinesisStreamingDestination, request, handler, context); } /** *

This operation allows you to perform reads and singleton writes on data * stored in DynamoDB, using PartiQL.

For PartiQL reads (SELECT * statement), if the total number of processed items exceeds the maximum dataset * size limit of 1 MB, the read stops and results are returned to the user as a * LastEvaluatedKey value to continue the read in a subsequent * operation. If the filter criteria in WHERE clause does not match * any data, the read will return an empty result set.

A single * SELECT statement response can return up to the maximum number of * items (if using the Limit parameter) or a maximum of 1 MB of data (and then * apply any filtering to the results using WHERE clause). If * LastEvaluatedKey is present in the response, you need to paginate * the result set. If NextToken is present, you need to paginate the * result set and include NextToken.

See Also:

AWS * API Reference

*/ virtual Model::ExecuteStatementOutcome ExecuteStatement(const Model::ExecuteStatementRequest& request) const; /** * A Callable wrapper for ExecuteStatement that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ExecuteStatementOutcomeCallable ExecuteStatementCallable(const ExecuteStatementRequestT& request) const { return SubmitCallable(&DynamoDBClient::ExecuteStatement, request); } /** * An Async wrapper for ExecuteStatement that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ExecuteStatementAsync(const ExecuteStatementRequestT& request, const ExecuteStatementResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::ExecuteStatement, request, handler, context); } /** *

This operation allows you to perform transactional reads or writes on data * stored in DynamoDB, using PartiQL.

The entire transaction must * consist of either read statements or write statements, you cannot mix both in * one transaction. The EXISTS function is an exception and can be used to check * the condition of specific attributes of the item in a similar manner to * ConditionCheck in the TransactWriteItems * API.

See Also:

AWS * API Reference

*/ virtual Model::ExecuteTransactionOutcome ExecuteTransaction(const Model::ExecuteTransactionRequest& request) const; /** * A Callable wrapper for ExecuteTransaction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ExecuteTransactionOutcomeCallable ExecuteTransactionCallable(const ExecuteTransactionRequestT& request) const { return SubmitCallable(&DynamoDBClient::ExecuteTransaction, request); } /** * An Async wrapper for ExecuteTransaction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ExecuteTransactionAsync(const ExecuteTransactionRequestT& request, const ExecuteTransactionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::ExecuteTransaction, request, handler, context); } /** *

Exports table data to an S3 bucket. The table must have point in time * recovery enabled, and you can export data from any time within the point in time * recovery window.

See Also:

AWS * API Reference

*/ virtual Model::ExportTableToPointInTimeOutcome ExportTableToPointInTime(const Model::ExportTableToPointInTimeRequest& request) const; /** * A Callable wrapper for ExportTableToPointInTime that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ExportTableToPointInTimeOutcomeCallable ExportTableToPointInTimeCallable(const ExportTableToPointInTimeRequestT& request) const { return SubmitCallable(&DynamoDBClient::ExportTableToPointInTime, request); } /** * An Async wrapper for ExportTableToPointInTime that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ExportTableToPointInTimeAsync(const ExportTableToPointInTimeRequestT& request, const ExportTableToPointInTimeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::ExportTableToPointInTime, request, handler, context); } /** *

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; /** * A Callable wrapper for GetItem that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetItemOutcomeCallable GetItemCallable(const GetItemRequestT& request) const { return SubmitCallable(&DynamoDBClient::GetItem, request); } /** * An Async wrapper for GetItem that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetItemAsync(const GetItemRequestT& request, const GetItemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::GetItem, request, handler, context); } /** *

Imports table data from an S3 bucket.

See Also:

AWS * API Reference

*/ virtual Model::ImportTableOutcome ImportTable(const Model::ImportTableRequest& request) const; /** * A Callable wrapper for ImportTable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ImportTableOutcomeCallable ImportTableCallable(const ImportTableRequestT& request) const { return SubmitCallable(&DynamoDBClient::ImportTable, request); } /** * An Async wrapper for ImportTable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ImportTableAsync(const ImportTableRequestT& request, const ImportTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::ImportTable, request, handler, context); } /** *

List backups associated with an Amazon Web Services 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 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 boundaries 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; /** * A Callable wrapper for ListBackups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListBackupsOutcomeCallable ListBackupsCallable(const ListBackupsRequestT& request) const { return SubmitCallable(&DynamoDBClient::ListBackups, request); } /** * An Async wrapper for ListBackups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListBackupsAsync(const ListBackupsRequestT& request, const ListBackupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::ListBackups, request, handler, context); } /** *

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; /** * A Callable wrapper for ListContributorInsights that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListContributorInsightsOutcomeCallable ListContributorInsightsCallable(const ListContributorInsightsRequestT& request) const { return SubmitCallable(&DynamoDBClient::ListContributorInsights, request); } /** * An Async wrapper for ListContributorInsights that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListContributorInsightsAsync(const ListContributorInsightsRequestT& request, const ListContributorInsightsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::ListContributorInsights, request, handler, context); } /** *

Lists completed exports within the past 90 days.

See Also:

* AWS * API Reference

*/ virtual Model::ListExportsOutcome ListExports(const Model::ListExportsRequest& request) const; /** * A Callable wrapper for ListExports that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListExportsOutcomeCallable ListExportsCallable(const ListExportsRequestT& request) const { return SubmitCallable(&DynamoDBClient::ListExports, request); } /** * An Async wrapper for ListExports that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListExportsAsync(const ListExportsRequestT& request, const ListExportsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::ListExports, request, handler, context); } /** *

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

*

This operation only applies to Version * 2017.11.29 (Legacy) of global tables. We recommend using Version * 2019.11.21 (Current) when creating new global tables, as it provides greater * flexibility, higher efficiency and consumes less write capacity than 2017.11.29 * (Legacy). To determine which version you are using, see Determining * the version. To update existing global tables from version 2017.11.29 * (Legacy) to version 2019.11.21 (Current), see * Updating global tables.

See Also:

AWS * API Reference

*/ virtual Model::ListGlobalTablesOutcome ListGlobalTables(const Model::ListGlobalTablesRequest& request) const; /** * A Callable wrapper for ListGlobalTables that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListGlobalTablesOutcomeCallable ListGlobalTablesCallable(const ListGlobalTablesRequestT& request) const { return SubmitCallable(&DynamoDBClient::ListGlobalTables, request); } /** * An Async wrapper for ListGlobalTables that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListGlobalTablesAsync(const ListGlobalTablesRequestT& request, const ListGlobalTablesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::ListGlobalTables, request, handler, context); } /** *

Lists completed imports within the past 90 days.

See Also:

* AWS * API Reference

*/ virtual Model::ListImportsOutcome ListImports(const Model::ListImportsRequest& request) const; /** * A Callable wrapper for ListImports that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListImportsOutcomeCallable ListImportsCallable(const ListImportsRequestT& request) const { return SubmitCallable(&DynamoDBClient::ListImports, request); } /** * An Async wrapper for ListImports that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListImportsAsync(const ListImportsRequestT& request, const ListImportsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::ListImports, request, handler, context); } /** *

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; /** * A Callable wrapper for ListTables that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTablesOutcomeCallable ListTablesCallable(const ListTablesRequestT& request) const { return SubmitCallable(&DynamoDBClient::ListTables, request); } /** * An Async wrapper for ListTables that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTablesAsync(const ListTablesRequestT& request, const ListTablesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::ListTables, request, handler, context); } /** *

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; /** * A Callable wrapper for ListTagsOfResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsOfResourceOutcomeCallable ListTagsOfResourceCallable(const ListTagsOfResourceRequestT& request) const { return SubmitCallable(&DynamoDBClient::ListTagsOfResource, request); } /** * An Async wrapper for ListTagsOfResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsOfResourceAsync(const ListTagsOfResourceRequestT& request, const ListTagsOfResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::ListTagsOfResource, request, handler, context); } /** *

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.

When you add an item, the primary * key attributes are the only required attributes.

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; /** * A Callable wrapper for PutItem that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutItemOutcomeCallable PutItemCallable(const PutItemRequestT& request) const { return SubmitCallable(&DynamoDBClient::PutItem, request); } /** * An Async wrapper for PutItem that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutItemAsync(const PutItemRequestT& request, const PutItemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::PutItem, request, handler, context); } /** *

You must provide the name of the partition key attribute and a single value * for that attribute. Query returns all items with that partition key * value. Optionally, you can provide a sort key attribute and use a comparison * operator to refine the search results.

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; /** * A Callable wrapper for Query that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::QueryOutcomeCallable QueryCallable(const QueryRequestT& request) const { return SubmitCallable(&DynamoDBClient::Query, request); } /** * An Async wrapper for Query that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void QueryAsync(const QueryRequestT& request, const QueryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::Query, request, handler, context); } /** *

Creates a new table from an existing backup. Any number of users can execute * up to 50 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; /** * A Callable wrapper for RestoreTableFromBackup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RestoreTableFromBackupOutcomeCallable RestoreTableFromBackupCallable(const RestoreTableFromBackupRequestT& request) const { return SubmitCallable(&DynamoDBClient::RestoreTableFromBackup, request); } /** * An Async wrapper for RestoreTableFromBackup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RestoreTableFromBackupAsync(const RestoreTableFromBackupRequestT& request, const RestoreTableFromBackupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::RestoreTableFromBackup, request, handler, context); } /** *

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; /** * A Callable wrapper for RestoreTableToPointInTime that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RestoreTableToPointInTimeOutcomeCallable RestoreTableToPointInTimeCallable(const RestoreTableToPointInTimeRequestT& request) const { return SubmitCallable(&DynamoDBClient::RestoreTableToPointInTime, request); } /** * An Async wrapper for RestoreTableToPointInTime that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RestoreTableToPointInTimeAsync(const RestoreTableToPointInTimeRequestT& request, const RestoreTableToPointInTimeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::RestoreTableToPointInTime, request, handler, context); } /** *

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 size of scanned items exceeds the maximum dataset size limit of * 1 MB, the scan completes and results are returned to the user. The * LastEvaluatedKey value is also returned and the requestor can use * the LastEvaluatedKey to continue the scan in a subsequent * operation. Each scan response also includes number of items that were scanned * (ScannedCount) as part of the request. If using a FilterExpression, * a scan result can result in no items meeting the criteria and the * Count will result in zero. If you did not use a * FilterExpression in the scan request, then Count is * the same as ScannedCount.

Count and * ScannedCount only return the count of items specific to a single * scan request and, unless the table is less than 1MB, do not represent the total * number of items in the table.

A single Scan * operation first reads up to the maximum number of items set (if using the * Limit parameter) or a maximum of 1 MB of data and then applies any * filtering to the results if a FilterExpression is provided. If * LastEvaluatedKey is present in the response, pagination is required * to complete the full table scan. 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.

By default, a * Scan uses eventually consistent reads when accessing the items in a * table. Therefore, the results from an eventually consistent Scan * may not include the latest item changes at the time the scan iterates through * each item in the table. If you require a strongly consistent read of each item * as the scan iterates through the items in the table, you can set the * ConsistentRead parameter to true. Strong consistency only relates * to the consistency of the read at the item level.

DynamoDB does * not provide snapshot isolation for a scan operation when the * ConsistentRead parameter is set to true. Thus, a DynamoDB scan * operation does not guarantee that all reads in a scan see a consistent snapshot * of the table when the scan operation was requested.

See * Also:

AWS API * Reference

*/ virtual Model::ScanOutcome Scan(const Model::ScanRequest& request) const; /** * A Callable wrapper for Scan that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ScanOutcomeCallable ScanCallable(const ScanRequestT& request) const { return SubmitCallable(&DynamoDBClient::Scan, request); } /** * An Async wrapper for Scan that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ScanAsync(const ScanRequestT& request, const ScanResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::Scan, request, handler, context); } /** *

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; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&DynamoDBClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::TagResource, request, handler, context); } /** *

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 100 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 Amazon Web Services 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 exceeded 4 MB.

    • *

See Also:

AWS * API Reference

*/ virtual Model::TransactGetItemsOutcome TransactGetItems(const Model::TransactGetItemsRequest& request) const; /** * A Callable wrapper for TransactGetItems that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TransactGetItemsOutcomeCallable TransactGetItemsCallable(const TransactGetItemsRequestT& request) const { return SubmitCallable(&DynamoDBClient::TransactGetItems, request); } /** * An Async wrapper for TransactGetItems that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TransactGetItemsAsync(const TransactGetItemsRequestT& request, const TransactGetItemsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::TransactGetItems, request, handler, context); } /** *

TransactWriteItems is a synchronous write operation that groups * up to 100 action requests. These actions can target items in different tables, * but not in different Amazon Web Services 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; /** * A Callable wrapper for TransactWriteItems that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TransactWriteItemsOutcomeCallable TransactWriteItemsCallable(const TransactWriteItemsRequestT& request) const { return SubmitCallable(&DynamoDBClient::TransactWriteItems, request); } /** * An Async wrapper for TransactWriteItems that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TransactWriteItemsAsync(const TransactWriteItemsRequestT& request, const TransactWriteItemsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::TransactWriteItems, request, handler, context); } /** *

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; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&DynamoDBClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::UntagResource, request, handler, context); } /** *

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; /** * A Callable wrapper for UpdateContinuousBackups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateContinuousBackupsOutcomeCallable UpdateContinuousBackupsCallable(const UpdateContinuousBackupsRequestT& request) const { return SubmitCallable(&DynamoDBClient::UpdateContinuousBackups, request); } /** * An Async wrapper for UpdateContinuousBackups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateContinuousBackupsAsync(const UpdateContinuousBackupsRequestT& request, const UpdateContinuousBackupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::UpdateContinuousBackups, request, handler, context); } /** *

Updates the status for contributor insights for a specific table or index. * CloudWatch Contributor Insights for DynamoDB graphs display the partition key * and (if applicable) sort key of frequently accessed items and frequently * throttled items in plaintext. If you require the use of Amazon Web Services Key * Management Service (KMS) to encrypt this table’s partition key and sort key data * with an Amazon Web Services managed key or customer managed key, you should not * enable CloudWatch Contributor Insights for DynamoDB for this * table.

See Also:

AWS * API Reference

*/ virtual Model::UpdateContributorInsightsOutcome UpdateContributorInsights(const Model::UpdateContributorInsightsRequest& request) const; /** * A Callable wrapper for UpdateContributorInsights that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateContributorInsightsOutcomeCallable UpdateContributorInsightsCallable(const UpdateContributorInsightsRequestT& request) const { return SubmitCallable(&DynamoDBClient::UpdateContributorInsights, request); } /** * An Async wrapper for UpdateContributorInsights that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateContributorInsightsAsync(const UpdateContributorInsightsRequestT& request, const UpdateContributorInsightsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::UpdateContributorInsights, request, handler, context); } /** *

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.

This operation only applies to Version * 2017.11.29 (Legacy) of global tables. We recommend using Version * 2019.11.21 (Current) when creating new global tables, as it provides greater * flexibility, higher efficiency and consumes less write capacity than 2017.11.29 * (Legacy). To determine which version you are using, see Determining * the version. To update existing global tables from version 2017.11.29 * (Legacy) to version 2019.11.21 (Current), see * Updating global tables.

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.

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; /** * A Callable wrapper for UpdateGlobalTable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateGlobalTableOutcomeCallable UpdateGlobalTableCallable(const UpdateGlobalTableRequestT& request) const { return SubmitCallable(&DynamoDBClient::UpdateGlobalTable, request); } /** * An Async wrapper for UpdateGlobalTable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateGlobalTableAsync(const UpdateGlobalTableRequestT& request, const UpdateGlobalTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::UpdateGlobalTable, request, handler, context); } /** *

Updates settings for a global table.

This operation only * applies to Version * 2017.11.29 (Legacy) of global tables. We recommend using Version * 2019.11.21 (Current) when creating new global tables, as it provides greater * flexibility, higher efficiency and consumes less write capacity than 2017.11.29 * (Legacy). To determine which version you are using, see Determining * the version. To update existing global tables from version 2017.11.29 * (Legacy) to version 2019.11.21 (Current), see * Updating global tables.

See Also:

AWS * API Reference

*/ virtual Model::UpdateGlobalTableSettingsOutcome UpdateGlobalTableSettings(const Model::UpdateGlobalTableSettingsRequest& request) const; /** * A Callable wrapper for UpdateGlobalTableSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateGlobalTableSettingsOutcomeCallable UpdateGlobalTableSettingsCallable(const UpdateGlobalTableSettingsRequestT& request) const { return SubmitCallable(&DynamoDBClient::UpdateGlobalTableSettings, request); } /** * An Async wrapper for UpdateGlobalTableSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateGlobalTableSettingsAsync(const UpdateGlobalTableSettingsRequestT& request, const UpdateGlobalTableSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::UpdateGlobalTableSettings, request, handler, context); } /** *

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; /** * A Callable wrapper for UpdateItem that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateItemOutcomeCallable UpdateItemCallable(const UpdateItemRequestT& request) const { return SubmitCallable(&DynamoDBClient::UpdateItem, request); } /** * An Async wrapper for UpdateItem that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateItemAsync(const UpdateItemRequestT& request, const UpdateItemResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::UpdateItem, request, handler, context); } /** *

Modifies the provisioned throughput settings, global secondary indexes, or * DynamoDB Streams settings for a given table.

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

You can only * perform one of the following operations at once:

  • Modify the * provisioned throughput settings of 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; /** * A Callable wrapper for UpdateTable that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateTableOutcomeCallable UpdateTableCallable(const UpdateTableRequestT& request) const { return SubmitCallable(&DynamoDBClient::UpdateTable, request); } /** * An Async wrapper for UpdateTable that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateTableAsync(const UpdateTableRequestT& request, const UpdateTableResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::UpdateTable, request, handler, context); } /** *

Updates auto scaling settings on your global tables at once.

*

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

See * Also:

AWS * API Reference

*/ virtual Model::UpdateTableReplicaAutoScalingOutcome UpdateTableReplicaAutoScaling(const Model::UpdateTableReplicaAutoScalingRequest& request) const; /** * A Callable wrapper for UpdateTableReplicaAutoScaling that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateTableReplicaAutoScalingOutcomeCallable UpdateTableReplicaAutoScalingCallable(const UpdateTableReplicaAutoScalingRequestT& request) const { return SubmitCallable(&DynamoDBClient::UpdateTableReplicaAutoScaling, request); } /** * An Async wrapper for UpdateTableReplicaAutoScaling that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateTableReplicaAutoScalingAsync(const UpdateTableReplicaAutoScalingRequestT& request, const UpdateTableReplicaAutoScalingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::UpdateTableReplicaAutoScaling, request, handler, context); } /** *

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; /** * A Callable wrapper for UpdateTimeToLive that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateTimeToLiveOutcomeCallable UpdateTimeToLiveCallable(const UpdateTimeToLiveRequestT& request) const { return SubmitCallable(&DynamoDBClient::UpdateTimeToLive, request); } /** * An Async wrapper for UpdateTimeToLive that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateTimeToLiveAsync(const UpdateTimeToLiveRequestT& request, const UpdateTimeToLiveResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&DynamoDBClient::UpdateTimeToLive, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const DynamoDBClientConfiguration& clientConfiguration); mutable Aws::Utils::ConcurrentCache m_endpointsCache; DynamoDBClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace DynamoDB } // namespace Aws