1 /** 2 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. 3 * SPDX-License-Identifier: Apache-2.0. 4 */ 5 6 #pragma once 7 #include <aws/dynamodb/DynamoDB_EXPORTS.h> 8 #include <aws/dynamodb/DynamoDBErrors.h> 9 #include <aws/core/client/AWSError.h> 10 #include <aws/core/client/ClientConfiguration.h> 11 #include <aws/core/client/AWSClient.h> 12 #include <aws/core/utils/memory/stl/AWSString.h> 13 #include <aws/core/utils/json/JsonSerializer.h> 14 #include <aws/dynamodb/model/BatchExecuteStatementResult.h> 15 #include <aws/dynamodb/model/BatchGetItemResult.h> 16 #include <aws/dynamodb/model/BatchWriteItemResult.h> 17 #include <aws/dynamodb/model/CreateBackupResult.h> 18 #include <aws/dynamodb/model/CreateGlobalTableResult.h> 19 #include <aws/dynamodb/model/CreateTableResult.h> 20 #include <aws/dynamodb/model/DeleteBackupResult.h> 21 #include <aws/dynamodb/model/DeleteItemResult.h> 22 #include <aws/dynamodb/model/DeleteTableResult.h> 23 #include <aws/dynamodb/model/DescribeBackupResult.h> 24 #include <aws/dynamodb/model/DescribeContinuousBackupsResult.h> 25 #include <aws/dynamodb/model/DescribeContributorInsightsResult.h> 26 #include <aws/dynamodb/model/DescribeEndpointsResult.h> 27 #include <aws/dynamodb/model/DescribeExportResult.h> 28 #include <aws/dynamodb/model/DescribeGlobalTableResult.h> 29 #include <aws/dynamodb/model/DescribeGlobalTableSettingsResult.h> 30 #include <aws/dynamodb/model/DescribeKinesisStreamingDestinationResult.h> 31 #include <aws/dynamodb/model/DescribeLimitsResult.h> 32 #include <aws/dynamodb/model/DescribeTableResult.h> 33 #include <aws/dynamodb/model/DescribeTableReplicaAutoScalingResult.h> 34 #include <aws/dynamodb/model/DescribeTimeToLiveResult.h> 35 #include <aws/dynamodb/model/DisableKinesisStreamingDestinationResult.h> 36 #include <aws/dynamodb/model/EnableKinesisStreamingDestinationResult.h> 37 #include <aws/dynamodb/model/ExecuteStatementResult.h> 38 #include <aws/dynamodb/model/ExecuteTransactionResult.h> 39 #include <aws/dynamodb/model/ExportTableToPointInTimeResult.h> 40 #include <aws/dynamodb/model/GetItemResult.h> 41 #include <aws/dynamodb/model/ListBackupsResult.h> 42 #include <aws/dynamodb/model/ListContributorInsightsResult.h> 43 #include <aws/dynamodb/model/ListExportsResult.h> 44 #include <aws/dynamodb/model/ListGlobalTablesResult.h> 45 #include <aws/dynamodb/model/ListTablesResult.h> 46 #include <aws/dynamodb/model/ListTagsOfResourceResult.h> 47 #include <aws/dynamodb/model/PutItemResult.h> 48 #include <aws/dynamodb/model/QueryResult.h> 49 #include <aws/dynamodb/model/RestoreTableFromBackupResult.h> 50 #include <aws/dynamodb/model/RestoreTableToPointInTimeResult.h> 51 #include <aws/dynamodb/model/ScanResult.h> 52 #include <aws/dynamodb/model/TransactGetItemsResult.h> 53 #include <aws/dynamodb/model/TransactWriteItemsResult.h> 54 #include <aws/dynamodb/model/UpdateContinuousBackupsResult.h> 55 #include <aws/dynamodb/model/UpdateContributorInsightsResult.h> 56 #include <aws/dynamodb/model/UpdateGlobalTableResult.h> 57 #include <aws/dynamodb/model/UpdateGlobalTableSettingsResult.h> 58 #include <aws/dynamodb/model/UpdateItemResult.h> 59 #include <aws/dynamodb/model/UpdateTableResult.h> 60 #include <aws/dynamodb/model/UpdateTableReplicaAutoScalingResult.h> 61 #include <aws/dynamodb/model/UpdateTimeToLiveResult.h> 62 #include <aws/core/NoResult.h> 63 #include <aws/core/client/AsyncCallerContext.h> 64 #include <aws/core/http/HttpTypes.h> 65 #include <aws/core/utils/ConcurrentCache.h> 66 #include <future> 67 #include <functional> 68 69 namespace Aws 70 { 71 72 namespace Http 73 { 74 class HttpClient; 75 class HttpClientFactory; 76 } // namespace Http 77 78 namespace Utils 79 { 80 template< typename R, typename E> class Outcome; 81 namespace Threading 82 { 83 class Executor; 84 } // namespace Threading 85 } // namespace Utils 86 87 namespace Auth 88 { 89 class AWSCredentials; 90 class AWSCredentialsProvider; 91 } // namespace Auth 92 93 namespace Client 94 { 95 class RetryStrategy; 96 } // namespace Client 97 98 namespace DynamoDB 99 { 100 101 namespace Model 102 { 103 class BatchExecuteStatementRequest; 104 class BatchGetItemRequest; 105 class BatchWriteItemRequest; 106 class CreateBackupRequest; 107 class CreateGlobalTableRequest; 108 class CreateTableRequest; 109 class DeleteBackupRequest; 110 class DeleteItemRequest; 111 class DeleteTableRequest; 112 class DescribeBackupRequest; 113 class DescribeContinuousBackupsRequest; 114 class DescribeContributorInsightsRequest; 115 class DescribeEndpointsRequest; 116 class DescribeExportRequest; 117 class DescribeGlobalTableRequest; 118 class DescribeGlobalTableSettingsRequest; 119 class DescribeKinesisStreamingDestinationRequest; 120 class DescribeLimitsRequest; 121 class DescribeTableRequest; 122 class DescribeTableReplicaAutoScalingRequest; 123 class DescribeTimeToLiveRequest; 124 class DisableKinesisStreamingDestinationRequest; 125 class EnableKinesisStreamingDestinationRequest; 126 class ExecuteStatementRequest; 127 class ExecuteTransactionRequest; 128 class ExportTableToPointInTimeRequest; 129 class GetItemRequest; 130 class ListBackupsRequest; 131 class ListContributorInsightsRequest; 132 class ListExportsRequest; 133 class ListGlobalTablesRequest; 134 class ListTablesRequest; 135 class ListTagsOfResourceRequest; 136 class PutItemRequest; 137 class QueryRequest; 138 class RestoreTableFromBackupRequest; 139 class RestoreTableToPointInTimeRequest; 140 class ScanRequest; 141 class TagResourceRequest; 142 class TransactGetItemsRequest; 143 class TransactWriteItemsRequest; 144 class UntagResourceRequest; 145 class UpdateContinuousBackupsRequest; 146 class UpdateContributorInsightsRequest; 147 class UpdateGlobalTableRequest; 148 class UpdateGlobalTableSettingsRequest; 149 class UpdateItemRequest; 150 class UpdateTableRequest; 151 class UpdateTableReplicaAutoScalingRequest; 152 class UpdateTimeToLiveRequest; 153 154 typedef Aws::Utils::Outcome<BatchExecuteStatementResult, DynamoDBError> BatchExecuteStatementOutcome; 155 typedef Aws::Utils::Outcome<BatchGetItemResult, DynamoDBError> BatchGetItemOutcome; 156 typedef Aws::Utils::Outcome<BatchWriteItemResult, DynamoDBError> BatchWriteItemOutcome; 157 typedef Aws::Utils::Outcome<CreateBackupResult, DynamoDBError> CreateBackupOutcome; 158 typedef Aws::Utils::Outcome<CreateGlobalTableResult, DynamoDBError> CreateGlobalTableOutcome; 159 typedef Aws::Utils::Outcome<CreateTableResult, DynamoDBError> CreateTableOutcome; 160 typedef Aws::Utils::Outcome<DeleteBackupResult, DynamoDBError> DeleteBackupOutcome; 161 typedef Aws::Utils::Outcome<DeleteItemResult, DynamoDBError> DeleteItemOutcome; 162 typedef Aws::Utils::Outcome<DeleteTableResult, DynamoDBError> DeleteTableOutcome; 163 typedef Aws::Utils::Outcome<DescribeBackupResult, DynamoDBError> DescribeBackupOutcome; 164 typedef Aws::Utils::Outcome<DescribeContinuousBackupsResult, DynamoDBError> DescribeContinuousBackupsOutcome; 165 typedef Aws::Utils::Outcome<DescribeContributorInsightsResult, DynamoDBError> DescribeContributorInsightsOutcome; 166 typedef Aws::Utils::Outcome<DescribeEndpointsResult, DynamoDBError> DescribeEndpointsOutcome; 167 typedef Aws::Utils::Outcome<DescribeExportResult, DynamoDBError> DescribeExportOutcome; 168 typedef Aws::Utils::Outcome<DescribeGlobalTableResult, DynamoDBError> DescribeGlobalTableOutcome; 169 typedef Aws::Utils::Outcome<DescribeGlobalTableSettingsResult, DynamoDBError> DescribeGlobalTableSettingsOutcome; 170 typedef Aws::Utils::Outcome<DescribeKinesisStreamingDestinationResult, DynamoDBError> DescribeKinesisStreamingDestinationOutcome; 171 typedef Aws::Utils::Outcome<DescribeLimitsResult, DynamoDBError> DescribeLimitsOutcome; 172 typedef Aws::Utils::Outcome<DescribeTableResult, DynamoDBError> DescribeTableOutcome; 173 typedef Aws::Utils::Outcome<DescribeTableReplicaAutoScalingResult, DynamoDBError> DescribeTableReplicaAutoScalingOutcome; 174 typedef Aws::Utils::Outcome<DescribeTimeToLiveResult, DynamoDBError> DescribeTimeToLiveOutcome; 175 typedef Aws::Utils::Outcome<DisableKinesisStreamingDestinationResult, DynamoDBError> DisableKinesisStreamingDestinationOutcome; 176 typedef Aws::Utils::Outcome<EnableKinesisStreamingDestinationResult, DynamoDBError> EnableKinesisStreamingDestinationOutcome; 177 typedef Aws::Utils::Outcome<ExecuteStatementResult, DynamoDBError> ExecuteStatementOutcome; 178 typedef Aws::Utils::Outcome<ExecuteTransactionResult, DynamoDBError> ExecuteTransactionOutcome; 179 typedef Aws::Utils::Outcome<ExportTableToPointInTimeResult, DynamoDBError> ExportTableToPointInTimeOutcome; 180 typedef Aws::Utils::Outcome<GetItemResult, DynamoDBError> GetItemOutcome; 181 typedef Aws::Utils::Outcome<ListBackupsResult, DynamoDBError> ListBackupsOutcome; 182 typedef Aws::Utils::Outcome<ListContributorInsightsResult, DynamoDBError> ListContributorInsightsOutcome; 183 typedef Aws::Utils::Outcome<ListExportsResult, DynamoDBError> ListExportsOutcome; 184 typedef Aws::Utils::Outcome<ListGlobalTablesResult, DynamoDBError> ListGlobalTablesOutcome; 185 typedef Aws::Utils::Outcome<ListTablesResult, DynamoDBError> ListTablesOutcome; 186 typedef Aws::Utils::Outcome<ListTagsOfResourceResult, DynamoDBError> ListTagsOfResourceOutcome; 187 typedef Aws::Utils::Outcome<PutItemResult, DynamoDBError> PutItemOutcome; 188 typedef Aws::Utils::Outcome<QueryResult, DynamoDBError> QueryOutcome; 189 typedef Aws::Utils::Outcome<RestoreTableFromBackupResult, DynamoDBError> RestoreTableFromBackupOutcome; 190 typedef Aws::Utils::Outcome<RestoreTableToPointInTimeResult, DynamoDBError> RestoreTableToPointInTimeOutcome; 191 typedef Aws::Utils::Outcome<ScanResult, DynamoDBError> ScanOutcome; 192 typedef Aws::Utils::Outcome<Aws::NoResult, DynamoDBError> TagResourceOutcome; 193 typedef Aws::Utils::Outcome<TransactGetItemsResult, DynamoDBError> TransactGetItemsOutcome; 194 typedef Aws::Utils::Outcome<TransactWriteItemsResult, DynamoDBError> TransactWriteItemsOutcome; 195 typedef Aws::Utils::Outcome<Aws::NoResult, DynamoDBError> UntagResourceOutcome; 196 typedef Aws::Utils::Outcome<UpdateContinuousBackupsResult, DynamoDBError> UpdateContinuousBackupsOutcome; 197 typedef Aws::Utils::Outcome<UpdateContributorInsightsResult, DynamoDBError> UpdateContributorInsightsOutcome; 198 typedef Aws::Utils::Outcome<UpdateGlobalTableResult, DynamoDBError> UpdateGlobalTableOutcome; 199 typedef Aws::Utils::Outcome<UpdateGlobalTableSettingsResult, DynamoDBError> UpdateGlobalTableSettingsOutcome; 200 typedef Aws::Utils::Outcome<UpdateItemResult, DynamoDBError> UpdateItemOutcome; 201 typedef Aws::Utils::Outcome<UpdateTableResult, DynamoDBError> UpdateTableOutcome; 202 typedef Aws::Utils::Outcome<UpdateTableReplicaAutoScalingResult, DynamoDBError> UpdateTableReplicaAutoScalingOutcome; 203 typedef Aws::Utils::Outcome<UpdateTimeToLiveResult, DynamoDBError> UpdateTimeToLiveOutcome; 204 205 typedef std::future<BatchExecuteStatementOutcome> BatchExecuteStatementOutcomeCallable; 206 typedef std::future<BatchGetItemOutcome> BatchGetItemOutcomeCallable; 207 typedef std::future<BatchWriteItemOutcome> BatchWriteItemOutcomeCallable; 208 typedef std::future<CreateBackupOutcome> CreateBackupOutcomeCallable; 209 typedef std::future<CreateGlobalTableOutcome> CreateGlobalTableOutcomeCallable; 210 typedef std::future<CreateTableOutcome> CreateTableOutcomeCallable; 211 typedef std::future<DeleteBackupOutcome> DeleteBackupOutcomeCallable; 212 typedef std::future<DeleteItemOutcome> DeleteItemOutcomeCallable; 213 typedef std::future<DeleteTableOutcome> DeleteTableOutcomeCallable; 214 typedef std::future<DescribeBackupOutcome> DescribeBackupOutcomeCallable; 215 typedef std::future<DescribeContinuousBackupsOutcome> DescribeContinuousBackupsOutcomeCallable; 216 typedef std::future<DescribeContributorInsightsOutcome> DescribeContributorInsightsOutcomeCallable; 217 typedef std::future<DescribeEndpointsOutcome> DescribeEndpointsOutcomeCallable; 218 typedef std::future<DescribeExportOutcome> DescribeExportOutcomeCallable; 219 typedef std::future<DescribeGlobalTableOutcome> DescribeGlobalTableOutcomeCallable; 220 typedef std::future<DescribeGlobalTableSettingsOutcome> DescribeGlobalTableSettingsOutcomeCallable; 221 typedef std::future<DescribeKinesisStreamingDestinationOutcome> DescribeKinesisStreamingDestinationOutcomeCallable; 222 typedef std::future<DescribeLimitsOutcome> DescribeLimitsOutcomeCallable; 223 typedef std::future<DescribeTableOutcome> DescribeTableOutcomeCallable; 224 typedef std::future<DescribeTableReplicaAutoScalingOutcome> DescribeTableReplicaAutoScalingOutcomeCallable; 225 typedef std::future<DescribeTimeToLiveOutcome> DescribeTimeToLiveOutcomeCallable; 226 typedef std::future<DisableKinesisStreamingDestinationOutcome> DisableKinesisStreamingDestinationOutcomeCallable; 227 typedef std::future<EnableKinesisStreamingDestinationOutcome> EnableKinesisStreamingDestinationOutcomeCallable; 228 typedef std::future<ExecuteStatementOutcome> ExecuteStatementOutcomeCallable; 229 typedef std::future<ExecuteTransactionOutcome> ExecuteTransactionOutcomeCallable; 230 typedef std::future<ExportTableToPointInTimeOutcome> ExportTableToPointInTimeOutcomeCallable; 231 typedef std::future<GetItemOutcome> GetItemOutcomeCallable; 232 typedef std::future<ListBackupsOutcome> ListBackupsOutcomeCallable; 233 typedef std::future<ListContributorInsightsOutcome> ListContributorInsightsOutcomeCallable; 234 typedef std::future<ListExportsOutcome> ListExportsOutcomeCallable; 235 typedef std::future<ListGlobalTablesOutcome> ListGlobalTablesOutcomeCallable; 236 typedef std::future<ListTablesOutcome> ListTablesOutcomeCallable; 237 typedef std::future<ListTagsOfResourceOutcome> ListTagsOfResourceOutcomeCallable; 238 typedef std::future<PutItemOutcome> PutItemOutcomeCallable; 239 typedef std::future<QueryOutcome> QueryOutcomeCallable; 240 typedef std::future<RestoreTableFromBackupOutcome> RestoreTableFromBackupOutcomeCallable; 241 typedef std::future<RestoreTableToPointInTimeOutcome> RestoreTableToPointInTimeOutcomeCallable; 242 typedef std::future<ScanOutcome> ScanOutcomeCallable; 243 typedef std::future<TagResourceOutcome> TagResourceOutcomeCallable; 244 typedef std::future<TransactGetItemsOutcome> TransactGetItemsOutcomeCallable; 245 typedef std::future<TransactWriteItemsOutcome> TransactWriteItemsOutcomeCallable; 246 typedef std::future<UntagResourceOutcome> UntagResourceOutcomeCallable; 247 typedef std::future<UpdateContinuousBackupsOutcome> UpdateContinuousBackupsOutcomeCallable; 248 typedef std::future<UpdateContributorInsightsOutcome> UpdateContributorInsightsOutcomeCallable; 249 typedef std::future<UpdateGlobalTableOutcome> UpdateGlobalTableOutcomeCallable; 250 typedef std::future<UpdateGlobalTableSettingsOutcome> UpdateGlobalTableSettingsOutcomeCallable; 251 typedef std::future<UpdateItemOutcome> UpdateItemOutcomeCallable; 252 typedef std::future<UpdateTableOutcome> UpdateTableOutcomeCallable; 253 typedef std::future<UpdateTableReplicaAutoScalingOutcome> UpdateTableReplicaAutoScalingOutcomeCallable; 254 typedef std::future<UpdateTimeToLiveOutcome> UpdateTimeToLiveOutcomeCallable; 255 } // namespace Model 256 257 class DynamoDBClient; 258 259 typedef std::function<void(const DynamoDBClient*, const Model::BatchExecuteStatementRequest&, const Model::BatchExecuteStatementOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > BatchExecuteStatementResponseReceivedHandler; 260 typedef std::function<void(const DynamoDBClient*, const Model::BatchGetItemRequest&, const Model::BatchGetItemOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > BatchGetItemResponseReceivedHandler; 261 typedef std::function<void(const DynamoDBClient*, const Model::BatchWriteItemRequest&, const Model::BatchWriteItemOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > BatchWriteItemResponseReceivedHandler; 262 typedef std::function<void(const DynamoDBClient*, const Model::CreateBackupRequest&, const Model::CreateBackupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateBackupResponseReceivedHandler; 263 typedef std::function<void(const DynamoDBClient*, const Model::CreateGlobalTableRequest&, const Model::CreateGlobalTableOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateGlobalTableResponseReceivedHandler; 264 typedef std::function<void(const DynamoDBClient*, const Model::CreateTableRequest&, const Model::CreateTableOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateTableResponseReceivedHandler; 265 typedef std::function<void(const DynamoDBClient*, const Model::DeleteBackupRequest&, const Model::DeleteBackupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteBackupResponseReceivedHandler; 266 typedef std::function<void(const DynamoDBClient*, const Model::DeleteItemRequest&, const Model::DeleteItemOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteItemResponseReceivedHandler; 267 typedef std::function<void(const DynamoDBClient*, const Model::DeleteTableRequest&, const Model::DeleteTableOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteTableResponseReceivedHandler; 268 typedef std::function<void(const DynamoDBClient*, const Model::DescribeBackupRequest&, const Model::DescribeBackupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeBackupResponseReceivedHandler; 269 typedef std::function<void(const DynamoDBClient*, const Model::DescribeContinuousBackupsRequest&, const Model::DescribeContinuousBackupsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeContinuousBackupsResponseReceivedHandler; 270 typedef std::function<void(const DynamoDBClient*, const Model::DescribeContributorInsightsRequest&, const Model::DescribeContributorInsightsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeContributorInsightsResponseReceivedHandler; 271 typedef std::function<void(const DynamoDBClient*, const Model::DescribeEndpointsRequest&, const Model::DescribeEndpointsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeEndpointsResponseReceivedHandler; 272 typedef std::function<void(const DynamoDBClient*, const Model::DescribeExportRequest&, const Model::DescribeExportOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeExportResponseReceivedHandler; 273 typedef std::function<void(const DynamoDBClient*, const Model::DescribeGlobalTableRequest&, const Model::DescribeGlobalTableOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeGlobalTableResponseReceivedHandler; 274 typedef std::function<void(const DynamoDBClient*, const Model::DescribeGlobalTableSettingsRequest&, const Model::DescribeGlobalTableSettingsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeGlobalTableSettingsResponseReceivedHandler; 275 typedef std::function<void(const DynamoDBClient*, const Model::DescribeKinesisStreamingDestinationRequest&, const Model::DescribeKinesisStreamingDestinationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeKinesisStreamingDestinationResponseReceivedHandler; 276 typedef std::function<void(const DynamoDBClient*, const Model::DescribeLimitsRequest&, const Model::DescribeLimitsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeLimitsResponseReceivedHandler; 277 typedef std::function<void(const DynamoDBClient*, const Model::DescribeTableRequest&, const Model::DescribeTableOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeTableResponseReceivedHandler; 278 typedef std::function<void(const DynamoDBClient*, const Model::DescribeTableReplicaAutoScalingRequest&, const Model::DescribeTableReplicaAutoScalingOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeTableReplicaAutoScalingResponseReceivedHandler; 279 typedef std::function<void(const DynamoDBClient*, const Model::DescribeTimeToLiveRequest&, const Model::DescribeTimeToLiveOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeTimeToLiveResponseReceivedHandler; 280 typedef std::function<void(const DynamoDBClient*, const Model::DisableKinesisStreamingDestinationRequest&, const Model::DisableKinesisStreamingDestinationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DisableKinesisStreamingDestinationResponseReceivedHandler; 281 typedef std::function<void(const DynamoDBClient*, const Model::EnableKinesisStreamingDestinationRequest&, const Model::EnableKinesisStreamingDestinationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > EnableKinesisStreamingDestinationResponseReceivedHandler; 282 typedef std::function<void(const DynamoDBClient*, const Model::ExecuteStatementRequest&, const Model::ExecuteStatementOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ExecuteStatementResponseReceivedHandler; 283 typedef std::function<void(const DynamoDBClient*, const Model::ExecuteTransactionRequest&, const Model::ExecuteTransactionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ExecuteTransactionResponseReceivedHandler; 284 typedef std::function<void(const DynamoDBClient*, const Model::ExportTableToPointInTimeRequest&, const Model::ExportTableToPointInTimeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ExportTableToPointInTimeResponseReceivedHandler; 285 typedef std::function<void(const DynamoDBClient*, const Model::GetItemRequest&, const Model::GetItemOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetItemResponseReceivedHandler; 286 typedef std::function<void(const DynamoDBClient*, const Model::ListBackupsRequest&, const Model::ListBackupsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListBackupsResponseReceivedHandler; 287 typedef std::function<void(const DynamoDBClient*, const Model::ListContributorInsightsRequest&, const Model::ListContributorInsightsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListContributorInsightsResponseReceivedHandler; 288 typedef std::function<void(const DynamoDBClient*, const Model::ListExportsRequest&, const Model::ListExportsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListExportsResponseReceivedHandler; 289 typedef std::function<void(const DynamoDBClient*, const Model::ListGlobalTablesRequest&, const Model::ListGlobalTablesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListGlobalTablesResponseReceivedHandler; 290 typedef std::function<void(const DynamoDBClient*, const Model::ListTablesRequest&, const Model::ListTablesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTablesResponseReceivedHandler; 291 typedef std::function<void(const DynamoDBClient*, const Model::ListTagsOfResourceRequest&, const Model::ListTagsOfResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTagsOfResourceResponseReceivedHandler; 292 typedef std::function<void(const DynamoDBClient*, const Model::PutItemRequest&, const Model::PutItemOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutItemResponseReceivedHandler; 293 typedef std::function<void(const DynamoDBClient*, const Model::QueryRequest&, const Model::QueryOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > QueryResponseReceivedHandler; 294 typedef std::function<void(const DynamoDBClient*, const Model::RestoreTableFromBackupRequest&, const Model::RestoreTableFromBackupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RestoreTableFromBackupResponseReceivedHandler; 295 typedef std::function<void(const DynamoDBClient*, const Model::RestoreTableToPointInTimeRequest&, const Model::RestoreTableToPointInTimeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RestoreTableToPointInTimeResponseReceivedHandler; 296 typedef std::function<void(const DynamoDBClient*, const Model::ScanRequest&, const Model::ScanOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ScanResponseReceivedHandler; 297 typedef std::function<void(const DynamoDBClient*, const Model::TagResourceRequest&, const Model::TagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > TagResourceResponseReceivedHandler; 298 typedef std::function<void(const DynamoDBClient*, const Model::TransactGetItemsRequest&, const Model::TransactGetItemsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > TransactGetItemsResponseReceivedHandler; 299 typedef std::function<void(const DynamoDBClient*, const Model::TransactWriteItemsRequest&, const Model::TransactWriteItemsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > TransactWriteItemsResponseReceivedHandler; 300 typedef std::function<void(const DynamoDBClient*, const Model::UntagResourceRequest&, const Model::UntagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UntagResourceResponseReceivedHandler; 301 typedef std::function<void(const DynamoDBClient*, const Model::UpdateContinuousBackupsRequest&, const Model::UpdateContinuousBackupsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateContinuousBackupsResponseReceivedHandler; 302 typedef std::function<void(const DynamoDBClient*, const Model::UpdateContributorInsightsRequest&, const Model::UpdateContributorInsightsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateContributorInsightsResponseReceivedHandler; 303 typedef std::function<void(const DynamoDBClient*, const Model::UpdateGlobalTableRequest&, const Model::UpdateGlobalTableOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateGlobalTableResponseReceivedHandler; 304 typedef std::function<void(const DynamoDBClient*, const Model::UpdateGlobalTableSettingsRequest&, const Model::UpdateGlobalTableSettingsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateGlobalTableSettingsResponseReceivedHandler; 305 typedef std::function<void(const DynamoDBClient*, const Model::UpdateItemRequest&, const Model::UpdateItemOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateItemResponseReceivedHandler; 306 typedef std::function<void(const DynamoDBClient*, const Model::UpdateTableRequest&, const Model::UpdateTableOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateTableResponseReceivedHandler; 307 typedef std::function<void(const DynamoDBClient*, const Model::UpdateTableReplicaAutoScalingRequest&, const Model::UpdateTableReplicaAutoScalingOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateTableReplicaAutoScalingResponseReceivedHandler; 308 typedef std::function<void(const DynamoDBClient*, const Model::UpdateTimeToLiveRequest&, const Model::UpdateTimeToLiveOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateTimeToLiveResponseReceivedHandler; 309 310 /** 311 * <fullname>Amazon DynamoDB</fullname> <p>Amazon DynamoDB is a fully managed NoSQL 312 * database service that provides fast and predictable performance with seamless 313 * scalability. DynamoDB lets you offload the administrative burdens of operating 314 * and scaling a distributed database, so that you don't have to worry about 315 * hardware provisioning, setup and configuration, replication, software patching, 316 * or cluster scaling.</p> <p>With DynamoDB, you can create database tables that 317 * can store and retrieve any amount of data, and serve any level of request 318 * traffic. You can scale up or scale down your tables' throughput capacity without 319 * downtime or performance degradation, and use the AWS Management Console to 320 * monitor resource utilization and performance metrics.</p> <p>DynamoDB 321 * automatically spreads the data and traffic for your tables over a sufficient 322 * number of servers to handle your throughput and storage requirements, while 323 * maintaining consistent and fast performance. All of your data is stored on solid 324 * state disks (SSDs) and automatically replicated across multiple Availability 325 * Zones in an AWS region, providing built-in high availability and data 326 * durability. </p> 327 */ 328 class AWS_DYNAMODB_API DynamoDBClient : public Aws::Client::AWSJsonClient 329 { 330 public: 331 typedef Aws::Client::AWSJsonClient BASECLASS; 332 333 /** 334 * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config 335 * is not specified, it will be initialized to default values. 336 */ 337 DynamoDBClient(const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration()); 338 339 /** 340 * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config 341 * is not specified, it will be initialized to default values. 342 */ 343 DynamoDBClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration()); 344 345 /** 346 * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, 347 * the default http client factory will be used 348 */ 349 DynamoDBClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider, 350 const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration()); 351 352 virtual ~DynamoDBClient(); 353 354 355 /** 356 * <p> This operation allows you to perform batch reads and writes on data stored 357 * in DynamoDB, using PartiQL. </p><p><h3>See Also:</h3> <a 358 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/BatchExecuteStatement">AWS 359 * API Reference</a></p> 360 */ 361 virtual Model::BatchExecuteStatementOutcome BatchExecuteStatement(const Model::BatchExecuteStatementRequest& request) const; 362 363 /** 364 * <p> This operation allows you to perform batch reads and writes on data stored 365 * in DynamoDB, using PartiQL. </p><p><h3>See Also:</h3> <a 366 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/BatchExecuteStatement">AWS 367 * API Reference</a></p> 368 * 369 * returns a future to the operation so that it can be executed in parallel to other requests. 370 */ 371 virtual Model::BatchExecuteStatementOutcomeCallable BatchExecuteStatementCallable(const Model::BatchExecuteStatementRequest& request) const; 372 373 /** 374 * <p> This operation allows you to perform batch reads and writes on data stored 375 * in DynamoDB, using PartiQL. </p><p><h3>See Also:</h3> <a 376 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/BatchExecuteStatement">AWS 377 * API Reference</a></p> 378 * 379 * Queues the request into a thread executor and triggers associated callback when operation has finished. 380 */ 381 virtual void BatchExecuteStatementAsync(const Model::BatchExecuteStatementRequest& request, const BatchExecuteStatementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 382 383 /** 384 * <p>The <code>BatchGetItem</code> operation returns the attributes of one or more 385 * items from one or more tables. You identify requested items by primary key.</p> 386 * <p>A single operation can retrieve up to 16 MB of data, which can contain as 387 * many as 100 items. <code>BatchGetItem</code> returns a partial result if the 388 * response size limit is exceeded, the table's provisioned throughput is exceeded, 389 * or an internal processing failure occurs. If a partial result is returned, the 390 * operation returns a value for <code>UnprocessedKeys</code>. You can use this 391 * value to retry the operation starting with the next item to get.</p> 392 * <p>If you request more than 100 items, <code>BatchGetItem</code> returns a 393 * <code>ValidationException</code> with the message "Too many items requested for 394 * the BatchGetItem call."</p> <p>For example, if you ask to retrieve 395 * 100 items, but each individual item is 300 KB in size, the system returns 52 396 * items (so as not to exceed the 16 MB limit). It also returns an appropriate 397 * <code>UnprocessedKeys</code> value so you can get the next page of results. If 398 * desired, your application can include its own logic to assemble the pages of 399 * results into one dataset.</p> <p>If <i>none</i> of the items can be processed 400 * due to insufficient provisioned throughput on all of the tables in the request, 401 * then <code>BatchGetItem</code> returns a 402 * <code>ProvisionedThroughputExceededException</code>. If <i>at least one</i> of 403 * the items is successfully processed, then <code>BatchGetItem</code> completes 404 * successfully, while returning the keys of the unread items in 405 * <code>UnprocessedKeys</code>.</p> <p>If DynamoDB returns any 406 * unprocessed items, you should retry the batch operation on those items. However, 407 * <i>we strongly recommend that you use an exponential backoff algorithm</i>. If 408 * you retry the batch operation immediately, the underlying read or write requests 409 * can still fail due to throttling on the individual tables. If you delay the 410 * batch operation using exponential backoff, the individual requests in the batch 411 * are much more likely to succeed.</p> <p>For more information, see <a 412 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#BatchOperations">Batch 413 * Operations and Error Handling</a> in the <i>Amazon DynamoDB Developer 414 * Guide</i>.</p> <p>By default, <code>BatchGetItem</code> performs 415 * eventually consistent reads on every table in the request. If you want strongly 416 * consistent reads instead, you can set <code>ConsistentRead</code> to 417 * <code>true</code> for any or all tables.</p> <p>In order to minimize response 418 * latency, <code>BatchGetItem</code> retrieves items in parallel.</p> <p>When 419 * designing your application, keep in mind that DynamoDB does not return items in 420 * any particular order. To help parse the response by item, include the primary 421 * key values for the items in your request in the 422 * <code>ProjectionExpression</code> parameter.</p> <p>If a requested item does not 423 * exist, it is not returned in the result. Requests for nonexistent items consume 424 * the minimum read capacity units according to the type of read. For more 425 * information, see <a 426 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html#CapacityUnitCalculations">Working 427 * with Tables</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><p><h3>See 428 * Also:</h3> <a 429 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/BatchGetItem">AWS 430 * API Reference</a></p> 431 */ 432 virtual Model::BatchGetItemOutcome BatchGetItem(const Model::BatchGetItemRequest& request) const; 433 434 /** 435 * <p>The <code>BatchGetItem</code> operation returns the attributes of one or more 436 * items from one or more tables. You identify requested items by primary key.</p> 437 * <p>A single operation can retrieve up to 16 MB of data, which can contain as 438 * many as 100 items. <code>BatchGetItem</code> returns a partial result if the 439 * response size limit is exceeded, the table's provisioned throughput is exceeded, 440 * or an internal processing failure occurs. If a partial result is returned, the 441 * operation returns a value for <code>UnprocessedKeys</code>. You can use this 442 * value to retry the operation starting with the next item to get.</p> 443 * <p>If you request more than 100 items, <code>BatchGetItem</code> returns a 444 * <code>ValidationException</code> with the message "Too many items requested for 445 * the BatchGetItem call."</p> <p>For example, if you ask to retrieve 446 * 100 items, but each individual item is 300 KB in size, the system returns 52 447 * items (so as not to exceed the 16 MB limit). It also returns an appropriate 448 * <code>UnprocessedKeys</code> value so you can get the next page of results. If 449 * desired, your application can include its own logic to assemble the pages of 450 * results into one dataset.</p> <p>If <i>none</i> of the items can be processed 451 * due to insufficient provisioned throughput on all of the tables in the request, 452 * then <code>BatchGetItem</code> returns a 453 * <code>ProvisionedThroughputExceededException</code>. If <i>at least one</i> of 454 * the items is successfully processed, then <code>BatchGetItem</code> completes 455 * successfully, while returning the keys of the unread items in 456 * <code>UnprocessedKeys</code>.</p> <p>If DynamoDB returns any 457 * unprocessed items, you should retry the batch operation on those items. However, 458 * <i>we strongly recommend that you use an exponential backoff algorithm</i>. If 459 * you retry the batch operation immediately, the underlying read or write requests 460 * can still fail due to throttling on the individual tables. If you delay the 461 * batch operation using exponential backoff, the individual requests in the batch 462 * are much more likely to succeed.</p> <p>For more information, see <a 463 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#BatchOperations">Batch 464 * Operations and Error Handling</a> in the <i>Amazon DynamoDB Developer 465 * Guide</i>.</p> <p>By default, <code>BatchGetItem</code> performs 466 * eventually consistent reads on every table in the request. If you want strongly 467 * consistent reads instead, you can set <code>ConsistentRead</code> to 468 * <code>true</code> for any or all tables.</p> <p>In order to minimize response 469 * latency, <code>BatchGetItem</code> retrieves items in parallel.</p> <p>When 470 * designing your application, keep in mind that DynamoDB does not return items in 471 * any particular order. To help parse the response by item, include the primary 472 * key values for the items in your request in the 473 * <code>ProjectionExpression</code> parameter.</p> <p>If a requested item does not 474 * exist, it is not returned in the result. Requests for nonexistent items consume 475 * the minimum read capacity units according to the type of read. For more 476 * information, see <a 477 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html#CapacityUnitCalculations">Working 478 * with Tables</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><p><h3>See 479 * Also:</h3> <a 480 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/BatchGetItem">AWS 481 * API Reference</a></p> 482 * 483 * returns a future to the operation so that it can be executed in parallel to other requests. 484 */ 485 virtual Model::BatchGetItemOutcomeCallable BatchGetItemCallable(const Model::BatchGetItemRequest& request) const; 486 487 /** 488 * <p>The <code>BatchGetItem</code> operation returns the attributes of one or more 489 * items from one or more tables. You identify requested items by primary key.</p> 490 * <p>A single operation can retrieve up to 16 MB of data, which can contain as 491 * many as 100 items. <code>BatchGetItem</code> returns a partial result if the 492 * response size limit is exceeded, the table's provisioned throughput is exceeded, 493 * or an internal processing failure occurs. If a partial result is returned, the 494 * operation returns a value for <code>UnprocessedKeys</code>. You can use this 495 * value to retry the operation starting with the next item to get.</p> 496 * <p>If you request more than 100 items, <code>BatchGetItem</code> returns a 497 * <code>ValidationException</code> with the message "Too many items requested for 498 * the BatchGetItem call."</p> <p>For example, if you ask to retrieve 499 * 100 items, but each individual item is 300 KB in size, the system returns 52 500 * items (so as not to exceed the 16 MB limit). It also returns an appropriate 501 * <code>UnprocessedKeys</code> value so you can get the next page of results. If 502 * desired, your application can include its own logic to assemble the pages of 503 * results into one dataset.</p> <p>If <i>none</i> of the items can be processed 504 * due to insufficient provisioned throughput on all of the tables in the request, 505 * then <code>BatchGetItem</code> returns a 506 * <code>ProvisionedThroughputExceededException</code>. If <i>at least one</i> of 507 * the items is successfully processed, then <code>BatchGetItem</code> completes 508 * successfully, while returning the keys of the unread items in 509 * <code>UnprocessedKeys</code>.</p> <p>If DynamoDB returns any 510 * unprocessed items, you should retry the batch operation on those items. However, 511 * <i>we strongly recommend that you use an exponential backoff algorithm</i>. If 512 * you retry the batch operation immediately, the underlying read or write requests 513 * can still fail due to throttling on the individual tables. If you delay the 514 * batch operation using exponential backoff, the individual requests in the batch 515 * are much more likely to succeed.</p> <p>For more information, see <a 516 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#BatchOperations">Batch 517 * Operations and Error Handling</a> in the <i>Amazon DynamoDB Developer 518 * Guide</i>.</p> <p>By default, <code>BatchGetItem</code> performs 519 * eventually consistent reads on every table in the request. If you want strongly 520 * consistent reads instead, you can set <code>ConsistentRead</code> to 521 * <code>true</code> for any or all tables.</p> <p>In order to minimize response 522 * latency, <code>BatchGetItem</code> retrieves items in parallel.</p> <p>When 523 * designing your application, keep in mind that DynamoDB does not return items in 524 * any particular order. To help parse the response by item, include the primary 525 * key values for the items in your request in the 526 * <code>ProjectionExpression</code> parameter.</p> <p>If a requested item does not 527 * exist, it is not returned in the result. Requests for nonexistent items consume 528 * the minimum read capacity units according to the type of read. For more 529 * information, see <a 530 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html#CapacityUnitCalculations">Working 531 * with Tables</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><p><h3>See 532 * Also:</h3> <a 533 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/BatchGetItem">AWS 534 * API Reference</a></p> 535 * 536 * Queues the request into a thread executor and triggers associated callback when operation has finished. 537 */ 538 virtual void BatchGetItemAsync(const Model::BatchGetItemRequest& request, const BatchGetItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 539 540 /** 541 * <p>The <code>BatchWriteItem</code> operation puts or deletes multiple items in 542 * one or more tables. A single call to <code>BatchWriteItem</code> can write up to 543 * 16 MB of data, which can comprise as many as 25 put or delete requests. 544 * Individual items to be written can be as large as 400 KB.</p> <p> 545 * <code>BatchWriteItem</code> cannot update items. To update items, use the 546 * <code>UpdateItem</code> action.</p> <p>The individual 547 * <code>PutItem</code> and <code>DeleteItem</code> operations specified in 548 * <code>BatchWriteItem</code> are atomic; however <code>BatchWriteItem</code> as a 549 * whole is not. If any requested operations fail because the table's provisioned 550 * throughput is exceeded or an internal processing failure occurs, the failed 551 * operations are returned in the <code>UnprocessedItems</code> response parameter. 552 * You can investigate and optionally resend the requests. Typically, you would 553 * call <code>BatchWriteItem</code> in a loop. Each iteration would check for 554 * unprocessed items and submit a new <code>BatchWriteItem</code> request with 555 * those unprocessed items until all items have been processed.</p> <p>If 556 * <i>none</i> of the items can be processed due to insufficient provisioned 557 * throughput on all of the tables in the request, then <code>BatchWriteItem</code> 558 * returns a <code>ProvisionedThroughputExceededException</code>.</p> 559 * <p>If DynamoDB returns any unprocessed items, you should retry the batch 560 * operation on those items. However, <i>we strongly recommend that you use an 561 * exponential backoff algorithm</i>. If you retry the batch operation immediately, 562 * the underlying read or write requests can still fail due to throttling on the 563 * individual tables. If you delay the batch operation using exponential backoff, 564 * the individual requests in the batch are much more likely to succeed.</p> <p>For 565 * more information, see <a 566 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#Programming.Errors.BatchOperations">Batch 567 * Operations and Error Handling</a> in the <i>Amazon DynamoDB Developer 568 * Guide</i>.</p> <p>With <code>BatchWriteItem</code>, you can 569 * efficiently write or delete large amounts of data, such as from Amazon EMR, or 570 * copy data from another database into DynamoDB. In order to improve performance 571 * with these large-scale operations, <code>BatchWriteItem</code> does not behave 572 * in the same way as individual <code>PutItem</code> and <code>DeleteItem</code> 573 * calls would. For example, you cannot specify conditions on individual put and 574 * delete requests, and <code>BatchWriteItem</code> does not return deleted items 575 * in the response.</p> <p>If you use a programming language that supports 576 * concurrency, you can use threads to write items in parallel. Your application 577 * must include the necessary logic to manage the threads. With languages that 578 * don't support threading, you must update or delete the specified items one at a 579 * time. In both situations, <code>BatchWriteItem</code> performs the specified put 580 * and delete operations in parallel, giving you the power of the thread pool 581 * approach without having to introduce complexity into your application.</p> 582 * <p>Parallel processing reduces latency, but each specified put and delete 583 * request consumes the same number of write capacity units whether it is processed 584 * in parallel or not. Delete operations on nonexistent items consume one write 585 * capacity unit.</p> <p>If one or more of the following is true, DynamoDB rejects 586 * the entire batch write operation:</p> <ul> <li> <p>One or more tables specified 587 * in the <code>BatchWriteItem</code> request does not exist.</p> </li> <li> 588 * <p>Primary key attributes specified on an item in the request do not match those 589 * in the corresponding table's primary key schema.</p> </li> <li> <p>You try to 590 * perform multiple operations on the same item in the same 591 * <code>BatchWriteItem</code> request. For example, you cannot put and delete the 592 * same item in the same <code>BatchWriteItem</code> request. </p> </li> <li> <p> 593 * Your request contains at least two items with identical hash and range keys 594 * (which essentially is two put operations). </p> </li> <li> <p>There are more 595 * than 25 requests in the batch.</p> </li> <li> <p>Any individual item in a batch 596 * exceeds 400 KB.</p> </li> <li> <p>The total request size exceeds 16 MB.</p> 597 * </li> </ul><p><h3>See Also:</h3> <a 598 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/BatchWriteItem">AWS 599 * API Reference</a></p> 600 */ 601 virtual Model::BatchWriteItemOutcome BatchWriteItem(const Model::BatchWriteItemRequest& request) const; 602 603 /** 604 * <p>The <code>BatchWriteItem</code> operation puts or deletes multiple items in 605 * one or more tables. A single call to <code>BatchWriteItem</code> can write up to 606 * 16 MB of data, which can comprise as many as 25 put or delete requests. 607 * Individual items to be written can be as large as 400 KB.</p> <p> 608 * <code>BatchWriteItem</code> cannot update items. To update items, use the 609 * <code>UpdateItem</code> action.</p> <p>The individual 610 * <code>PutItem</code> and <code>DeleteItem</code> operations specified in 611 * <code>BatchWriteItem</code> are atomic; however <code>BatchWriteItem</code> as a 612 * whole is not. If any requested operations fail because the table's provisioned 613 * throughput is exceeded or an internal processing failure occurs, the failed 614 * operations are returned in the <code>UnprocessedItems</code> response parameter. 615 * You can investigate and optionally resend the requests. Typically, you would 616 * call <code>BatchWriteItem</code> in a loop. Each iteration would check for 617 * unprocessed items and submit a new <code>BatchWriteItem</code> request with 618 * those unprocessed items until all items have been processed.</p> <p>If 619 * <i>none</i> of the items can be processed due to insufficient provisioned 620 * throughput on all of the tables in the request, then <code>BatchWriteItem</code> 621 * returns a <code>ProvisionedThroughputExceededException</code>.</p> 622 * <p>If DynamoDB returns any unprocessed items, you should retry the batch 623 * operation on those items. However, <i>we strongly recommend that you use an 624 * exponential backoff algorithm</i>. If you retry the batch operation immediately, 625 * the underlying read or write requests can still fail due to throttling on the 626 * individual tables. If you delay the batch operation using exponential backoff, 627 * the individual requests in the batch are much more likely to succeed.</p> <p>For 628 * more information, see <a 629 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#Programming.Errors.BatchOperations">Batch 630 * Operations and Error Handling</a> in the <i>Amazon DynamoDB Developer 631 * Guide</i>.</p> <p>With <code>BatchWriteItem</code>, you can 632 * efficiently write or delete large amounts of data, such as from Amazon EMR, or 633 * copy data from another database into DynamoDB. In order to improve performance 634 * with these large-scale operations, <code>BatchWriteItem</code> does not behave 635 * in the same way as individual <code>PutItem</code> and <code>DeleteItem</code> 636 * calls would. For example, you cannot specify conditions on individual put and 637 * delete requests, and <code>BatchWriteItem</code> does not return deleted items 638 * in the response.</p> <p>If you use a programming language that supports 639 * concurrency, you can use threads to write items in parallel. Your application 640 * must include the necessary logic to manage the threads. With languages that 641 * don't support threading, you must update or delete the specified items one at a 642 * time. In both situations, <code>BatchWriteItem</code> performs the specified put 643 * and delete operations in parallel, giving you the power of the thread pool 644 * approach without having to introduce complexity into your application.</p> 645 * <p>Parallel processing reduces latency, but each specified put and delete 646 * request consumes the same number of write capacity units whether it is processed 647 * in parallel or not. Delete operations on nonexistent items consume one write 648 * capacity unit.</p> <p>If one or more of the following is true, DynamoDB rejects 649 * the entire batch write operation:</p> <ul> <li> <p>One or more tables specified 650 * in the <code>BatchWriteItem</code> request does not exist.</p> </li> <li> 651 * <p>Primary key attributes specified on an item in the request do not match those 652 * in the corresponding table's primary key schema.</p> </li> <li> <p>You try to 653 * perform multiple operations on the same item in the same 654 * <code>BatchWriteItem</code> request. For example, you cannot put and delete the 655 * same item in the same <code>BatchWriteItem</code> request. </p> </li> <li> <p> 656 * Your request contains at least two items with identical hash and range keys 657 * (which essentially is two put operations). </p> </li> <li> <p>There are more 658 * than 25 requests in the batch.</p> </li> <li> <p>Any individual item in a batch 659 * exceeds 400 KB.</p> </li> <li> <p>The total request size exceeds 16 MB.</p> 660 * </li> </ul><p><h3>See Also:</h3> <a 661 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/BatchWriteItem">AWS 662 * API Reference</a></p> 663 * 664 * returns a future to the operation so that it can be executed in parallel to other requests. 665 */ 666 virtual Model::BatchWriteItemOutcomeCallable BatchWriteItemCallable(const Model::BatchWriteItemRequest& request) const; 667 668 /** 669 * <p>The <code>BatchWriteItem</code> operation puts or deletes multiple items in 670 * one or more tables. A single call to <code>BatchWriteItem</code> can write up to 671 * 16 MB of data, which can comprise as many as 25 put or delete requests. 672 * Individual items to be written can be as large as 400 KB.</p> <p> 673 * <code>BatchWriteItem</code> cannot update items. To update items, use the 674 * <code>UpdateItem</code> action.</p> <p>The individual 675 * <code>PutItem</code> and <code>DeleteItem</code> operations specified in 676 * <code>BatchWriteItem</code> are atomic; however <code>BatchWriteItem</code> as a 677 * whole is not. If any requested operations fail because the table's provisioned 678 * throughput is exceeded or an internal processing failure occurs, the failed 679 * operations are returned in the <code>UnprocessedItems</code> response parameter. 680 * You can investigate and optionally resend the requests. Typically, you would 681 * call <code>BatchWriteItem</code> in a loop. Each iteration would check for 682 * unprocessed items and submit a new <code>BatchWriteItem</code> request with 683 * those unprocessed items until all items have been processed.</p> <p>If 684 * <i>none</i> of the items can be processed due to insufficient provisioned 685 * throughput on all of the tables in the request, then <code>BatchWriteItem</code> 686 * returns a <code>ProvisionedThroughputExceededException</code>.</p> 687 * <p>If DynamoDB returns any unprocessed items, you should retry the batch 688 * operation on those items. However, <i>we strongly recommend that you use an 689 * exponential backoff algorithm</i>. If you retry the batch operation immediately, 690 * the underlying read or write requests can still fail due to throttling on the 691 * individual tables. If you delay the batch operation using exponential backoff, 692 * the individual requests in the batch are much more likely to succeed.</p> <p>For 693 * more information, see <a 694 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#Programming.Errors.BatchOperations">Batch 695 * Operations and Error Handling</a> in the <i>Amazon DynamoDB Developer 696 * Guide</i>.</p> <p>With <code>BatchWriteItem</code>, you can 697 * efficiently write or delete large amounts of data, such as from Amazon EMR, or 698 * copy data from another database into DynamoDB. In order to improve performance 699 * with these large-scale operations, <code>BatchWriteItem</code> does not behave 700 * in the same way as individual <code>PutItem</code> and <code>DeleteItem</code> 701 * calls would. For example, you cannot specify conditions on individual put and 702 * delete requests, and <code>BatchWriteItem</code> does not return deleted items 703 * in the response.</p> <p>If you use a programming language that supports 704 * concurrency, you can use threads to write items in parallel. Your application 705 * must include the necessary logic to manage the threads. With languages that 706 * don't support threading, you must update or delete the specified items one at a 707 * time. In both situations, <code>BatchWriteItem</code> performs the specified put 708 * and delete operations in parallel, giving you the power of the thread pool 709 * approach without having to introduce complexity into your application.</p> 710 * <p>Parallel processing reduces latency, but each specified put and delete 711 * request consumes the same number of write capacity units whether it is processed 712 * in parallel or not. Delete operations on nonexistent items consume one write 713 * capacity unit.</p> <p>If one or more of the following is true, DynamoDB rejects 714 * the entire batch write operation:</p> <ul> <li> <p>One or more tables specified 715 * in the <code>BatchWriteItem</code> request does not exist.</p> </li> <li> 716 * <p>Primary key attributes specified on an item in the request do not match those 717 * in the corresponding table's primary key schema.</p> </li> <li> <p>You try to 718 * perform multiple operations on the same item in the same 719 * <code>BatchWriteItem</code> request. For example, you cannot put and delete the 720 * same item in the same <code>BatchWriteItem</code> request. </p> </li> <li> <p> 721 * Your request contains at least two items with identical hash and range keys 722 * (which essentially is two put operations). </p> </li> <li> <p>There are more 723 * than 25 requests in the batch.</p> </li> <li> <p>Any individual item in a batch 724 * exceeds 400 KB.</p> </li> <li> <p>The total request size exceeds 16 MB.</p> 725 * </li> </ul><p><h3>See Also:</h3> <a 726 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/BatchWriteItem">AWS 727 * API Reference</a></p> 728 * 729 * Queues the request into a thread executor and triggers associated callback when operation has finished. 730 */ 731 virtual void BatchWriteItemAsync(const Model::BatchWriteItemRequest& request, const BatchWriteItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 732 733 /** 734 * <p>Creates a backup for an existing table.</p> <p> Each time you create an 735 * on-demand backup, the entire table data is backed up. There is no limit to the 736 * number of on-demand backups that can be taken. </p> <p> When you create an 737 * on-demand backup, a time marker of the request is cataloged, and the backup is 738 * created asynchronously, by applying all changes until the time of the request to 739 * the last full table snapshot. Backup requests are processed instantaneously and 740 * become available for restore within minutes. </p> <p>You can call 741 * <code>CreateBackup</code> at a maximum rate of 50 times per second.</p> <p>All 742 * backups in DynamoDB work without consuming any provisioned throughput on the 743 * table.</p> <p> If you submit a backup request on 2018-12-14 at 14:25:00, the 744 * backup is guaranteed to contain all data committed to the table up to 14:24:00, 745 * and data committed after 14:26:00 will not be. The backup might contain data 746 * modifications made between 14:24:00 and 14:26:00. On-demand backup does not 747 * support causal consistency. </p> <p> Along with data, the following are also 748 * included on the backups: </p> <ul> <li> <p>Global secondary indexes (GSIs)</p> 749 * </li> <li> <p>Local secondary indexes (LSIs)</p> </li> <li> <p>Streams</p> </li> 750 * <li> <p>Provisioned read and write capacity</p> </li> </ul><p><h3>See Also:</h3> 751 * <a 752 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/CreateBackup">AWS 753 * API Reference</a></p> 754 */ 755 virtual Model::CreateBackupOutcome CreateBackup(const Model::CreateBackupRequest& request) const; 756 757 /** 758 * <p>Creates a backup for an existing table.</p> <p> Each time you create an 759 * on-demand backup, the entire table data is backed up. There is no limit to the 760 * number of on-demand backups that can be taken. </p> <p> When you create an 761 * on-demand backup, a time marker of the request is cataloged, and the backup is 762 * created asynchronously, by applying all changes until the time of the request to 763 * the last full table snapshot. Backup requests are processed instantaneously and 764 * become available for restore within minutes. </p> <p>You can call 765 * <code>CreateBackup</code> at a maximum rate of 50 times per second.</p> <p>All 766 * backups in DynamoDB work without consuming any provisioned throughput on the 767 * table.</p> <p> If you submit a backup request on 2018-12-14 at 14:25:00, the 768 * backup is guaranteed to contain all data committed to the table up to 14:24:00, 769 * and data committed after 14:26:00 will not be. The backup might contain data 770 * modifications made between 14:24:00 and 14:26:00. On-demand backup does not 771 * support causal consistency. </p> <p> Along with data, the following are also 772 * included on the backups: </p> <ul> <li> <p>Global secondary indexes (GSIs)</p> 773 * </li> <li> <p>Local secondary indexes (LSIs)</p> </li> <li> <p>Streams</p> </li> 774 * <li> <p>Provisioned read and write capacity</p> </li> </ul><p><h3>See Also:</h3> 775 * <a 776 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/CreateBackup">AWS 777 * API Reference</a></p> 778 * 779 * returns a future to the operation so that it can be executed in parallel to other requests. 780 */ 781 virtual Model::CreateBackupOutcomeCallable CreateBackupCallable(const Model::CreateBackupRequest& request) const; 782 783 /** 784 * <p>Creates a backup for an existing table.</p> <p> Each time you create an 785 * on-demand backup, the entire table data is backed up. There is no limit to the 786 * number of on-demand backups that can be taken. </p> <p> When you create an 787 * on-demand backup, a time marker of the request is cataloged, and the backup is 788 * created asynchronously, by applying all changes until the time of the request to 789 * the last full table snapshot. Backup requests are processed instantaneously and 790 * become available for restore within minutes. </p> <p>You can call 791 * <code>CreateBackup</code> at a maximum rate of 50 times per second.</p> <p>All 792 * backups in DynamoDB work without consuming any provisioned throughput on the 793 * table.</p> <p> If you submit a backup request on 2018-12-14 at 14:25:00, the 794 * backup is guaranteed to contain all data committed to the table up to 14:24:00, 795 * and data committed after 14:26:00 will not be. The backup might contain data 796 * modifications made between 14:24:00 and 14:26:00. On-demand backup does not 797 * support causal consistency. </p> <p> Along with data, the following are also 798 * included on the backups: </p> <ul> <li> <p>Global secondary indexes (GSIs)</p> 799 * </li> <li> <p>Local secondary indexes (LSIs)</p> </li> <li> <p>Streams</p> </li> 800 * <li> <p>Provisioned read and write capacity</p> </li> </ul><p><h3>See Also:</h3> 801 * <a 802 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/CreateBackup">AWS 803 * API Reference</a></p> 804 * 805 * Queues the request into a thread executor and triggers associated callback when operation has finished. 806 */ 807 virtual void CreateBackupAsync(const Model::CreateBackupRequest& request, const CreateBackupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 808 809 /** 810 * <p>Creates a global table from an existing table. A global table creates a 811 * replication relationship between two or more DynamoDB tables with the same table 812 * name in the provided Regions. </p> <p>This operation only applies to <a 813 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html">Version 814 * 2017.11.29</a> of global tables.</p> <p>If you want to add a new replica 815 * table to a global table, each of the following conditions must be true:</p> <ul> 816 * <li> <p>The table must have the same primary key as all of the other 817 * replicas.</p> </li> <li> <p>The table must have the same name as all of the 818 * other replicas.</p> </li> <li> <p>The table must have DynamoDB Streams enabled, 819 * with the stream containing both the new and the old images of the item.</p> 820 * </li> <li> <p>None of the replica tables in the global table can contain any 821 * data.</p> </li> </ul> <p> If global secondary indexes are specified, then the 822 * following conditions must also be met: </p> <ul> <li> <p> The global secondary 823 * indexes must have the same name. </p> </li> <li> <p> The global secondary 824 * indexes must have the same hash key and sort key (if present). </p> </li> </ul> 825 * <p> If local secondary indexes are specified, then the following conditions must 826 * also be met: </p> <ul> <li> <p> The local secondary indexes must have the same 827 * name. </p> </li> <li> <p> The local secondary indexes must have the same hash 828 * key and sort key (if present). </p> </li> </ul> <p> Write capacity 829 * settings should be set consistently across your replica tables and secondary 830 * indexes. DynamoDB strongly recommends enabling auto scaling to manage the write 831 * capacity settings for all of your global tables replicas and indexes. </p> <p> 832 * If you prefer to manage write capacity settings manually, you should provision 833 * equal replicated write capacity units to your replica tables. You should also 834 * provision equal replicated write capacity units to matching secondary indexes 835 * across your global table. </p> <p><h3>See Also:</h3> <a 836 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/CreateGlobalTable">AWS 837 * API Reference</a></p> 838 */ 839 virtual Model::CreateGlobalTableOutcome CreateGlobalTable(const Model::CreateGlobalTableRequest& request) const; 840 841 /** 842 * <p>Creates a global table from an existing table. A global table creates a 843 * replication relationship between two or more DynamoDB tables with the same table 844 * name in the provided Regions. </p> <p>This operation only applies to <a 845 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html">Version 846 * 2017.11.29</a> of global tables.</p> <p>If you want to add a new replica 847 * table to a global table, each of the following conditions must be true:</p> <ul> 848 * <li> <p>The table must have the same primary key as all of the other 849 * replicas.</p> </li> <li> <p>The table must have the same name as all of the 850 * other replicas.</p> </li> <li> <p>The table must have DynamoDB Streams enabled, 851 * with the stream containing both the new and the old images of the item.</p> 852 * </li> <li> <p>None of the replica tables in the global table can contain any 853 * data.</p> </li> </ul> <p> If global secondary indexes are specified, then the 854 * following conditions must also be met: </p> <ul> <li> <p> The global secondary 855 * indexes must have the same name. </p> </li> <li> <p> The global secondary 856 * indexes must have the same hash key and sort key (if present). </p> </li> </ul> 857 * <p> If local secondary indexes are specified, then the following conditions must 858 * also be met: </p> <ul> <li> <p> The local secondary indexes must have the same 859 * name. </p> </li> <li> <p> The local secondary indexes must have the same hash 860 * key and sort key (if present). </p> </li> </ul> <p> Write capacity 861 * settings should be set consistently across your replica tables and secondary 862 * indexes. DynamoDB strongly recommends enabling auto scaling to manage the write 863 * capacity settings for all of your global tables replicas and indexes. </p> <p> 864 * If you prefer to manage write capacity settings manually, you should provision 865 * equal replicated write capacity units to your replica tables. You should also 866 * provision equal replicated write capacity units to matching secondary indexes 867 * across your global table. </p> <p><h3>See Also:</h3> <a 868 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/CreateGlobalTable">AWS 869 * API Reference</a></p> 870 * 871 * returns a future to the operation so that it can be executed in parallel to other requests. 872 */ 873 virtual Model::CreateGlobalTableOutcomeCallable CreateGlobalTableCallable(const Model::CreateGlobalTableRequest& request) const; 874 875 /** 876 * <p>Creates a global table from an existing table. A global table creates a 877 * replication relationship between two or more DynamoDB tables with the same table 878 * name in the provided Regions. </p> <p>This operation only applies to <a 879 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html">Version 880 * 2017.11.29</a> of global tables.</p> <p>If you want to add a new replica 881 * table to a global table, each of the following conditions must be true:</p> <ul> 882 * <li> <p>The table must have the same primary key as all of the other 883 * replicas.</p> </li> <li> <p>The table must have the same name as all of the 884 * other replicas.</p> </li> <li> <p>The table must have DynamoDB Streams enabled, 885 * with the stream containing both the new and the old images of the item.</p> 886 * </li> <li> <p>None of the replica tables in the global table can contain any 887 * data.</p> </li> </ul> <p> If global secondary indexes are specified, then the 888 * following conditions must also be met: </p> <ul> <li> <p> The global secondary 889 * indexes must have the same name. </p> </li> <li> <p> The global secondary 890 * indexes must have the same hash key and sort key (if present). </p> </li> </ul> 891 * <p> If local secondary indexes are specified, then the following conditions must 892 * also be met: </p> <ul> <li> <p> The local secondary indexes must have the same 893 * name. </p> </li> <li> <p> The local secondary indexes must have the same hash 894 * key and sort key (if present). </p> </li> </ul> <p> Write capacity 895 * settings should be set consistently across your replica tables and secondary 896 * indexes. DynamoDB strongly recommends enabling auto scaling to manage the write 897 * capacity settings for all of your global tables replicas and indexes. </p> <p> 898 * If you prefer to manage write capacity settings manually, you should provision 899 * equal replicated write capacity units to your replica tables. You should also 900 * provision equal replicated write capacity units to matching secondary indexes 901 * across your global table. </p> <p><h3>See Also:</h3> <a 902 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/CreateGlobalTable">AWS 903 * API Reference</a></p> 904 * 905 * Queues the request into a thread executor and triggers associated callback when operation has finished. 906 */ 907 virtual void CreateGlobalTableAsync(const Model::CreateGlobalTableRequest& request, const CreateGlobalTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 908 909 /** 910 * <p>The <code>CreateTable</code> operation adds a new table to your account. In 911 * an AWS account, table names must be unique within each Region. That is, you can 912 * have two tables with same name if you create the tables in different 913 * Regions.</p> <p> <code>CreateTable</code> is an asynchronous operation. Upon 914 * receiving a <code>CreateTable</code> request, DynamoDB immediately returns a 915 * response with a <code>TableStatus</code> of <code>CREATING</code>. After the 916 * table is created, DynamoDB sets the <code>TableStatus</code> to 917 * <code>ACTIVE</code>. You can perform read and write operations only on an 918 * <code>ACTIVE</code> table. </p> <p>You can optionally define secondary indexes 919 * on the new table, as part of the <code>CreateTable</code> operation. If you want 920 * to create multiple tables with secondary indexes on them, you must create the 921 * tables sequentially. Only one table with secondary indexes can be in the 922 * <code>CREATING</code> state at any given time.</p> <p>You can use the 923 * <code>DescribeTable</code> action to check the table status.</p><p><h3>See 924 * Also:</h3> <a 925 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/CreateTable">AWS 926 * API Reference</a></p> 927 */ 928 virtual Model::CreateTableOutcome CreateTable(const Model::CreateTableRequest& request) const; 929 930 /** 931 * <p>The <code>CreateTable</code> operation adds a new table to your account. In 932 * an AWS account, table names must be unique within each Region. That is, you can 933 * have two tables with same name if you create the tables in different 934 * Regions.</p> <p> <code>CreateTable</code> is an asynchronous operation. Upon 935 * receiving a <code>CreateTable</code> request, DynamoDB immediately returns a 936 * response with a <code>TableStatus</code> of <code>CREATING</code>. After the 937 * table is created, DynamoDB sets the <code>TableStatus</code> to 938 * <code>ACTIVE</code>. You can perform read and write operations only on an 939 * <code>ACTIVE</code> table. </p> <p>You can optionally define secondary indexes 940 * on the new table, as part of the <code>CreateTable</code> operation. If you want 941 * to create multiple tables with secondary indexes on them, you must create the 942 * tables sequentially. Only one table with secondary indexes can be in the 943 * <code>CREATING</code> state at any given time.</p> <p>You can use the 944 * <code>DescribeTable</code> action to check the table status.</p><p><h3>See 945 * Also:</h3> <a 946 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/CreateTable">AWS 947 * API Reference</a></p> 948 * 949 * returns a future to the operation so that it can be executed in parallel to other requests. 950 */ 951 virtual Model::CreateTableOutcomeCallable CreateTableCallable(const Model::CreateTableRequest& request) const; 952 953 /** 954 * <p>The <code>CreateTable</code> operation adds a new table to your account. In 955 * an AWS account, table names must be unique within each Region. That is, you can 956 * have two tables with same name if you create the tables in different 957 * Regions.</p> <p> <code>CreateTable</code> is an asynchronous operation. Upon 958 * receiving a <code>CreateTable</code> request, DynamoDB immediately returns a 959 * response with a <code>TableStatus</code> of <code>CREATING</code>. After the 960 * table is created, DynamoDB sets the <code>TableStatus</code> to 961 * <code>ACTIVE</code>. You can perform read and write operations only on an 962 * <code>ACTIVE</code> table. </p> <p>You can optionally define secondary indexes 963 * on the new table, as part of the <code>CreateTable</code> operation. If you want 964 * to create multiple tables with secondary indexes on them, you must create the 965 * tables sequentially. Only one table with secondary indexes can be in the 966 * <code>CREATING</code> state at any given time.</p> <p>You can use the 967 * <code>DescribeTable</code> action to check the table status.</p><p><h3>See 968 * Also:</h3> <a 969 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/CreateTable">AWS 970 * API Reference</a></p> 971 * 972 * Queues the request into a thread executor and triggers associated callback when operation has finished. 973 */ 974 virtual void CreateTableAsync(const Model::CreateTableRequest& request, const CreateTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 975 976 /** 977 * <p>Deletes an existing backup of a table.</p> <p>You can call 978 * <code>DeleteBackup</code> at a maximum rate of 10 times per 979 * second.</p><p><h3>See Also:</h3> <a 980 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DeleteBackup">AWS 981 * API Reference</a></p> 982 */ 983 virtual Model::DeleteBackupOutcome DeleteBackup(const Model::DeleteBackupRequest& request) const; 984 985 /** 986 * <p>Deletes an existing backup of a table.</p> <p>You can call 987 * <code>DeleteBackup</code> at a maximum rate of 10 times per 988 * second.</p><p><h3>See Also:</h3> <a 989 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DeleteBackup">AWS 990 * API Reference</a></p> 991 * 992 * returns a future to the operation so that it can be executed in parallel to other requests. 993 */ 994 virtual Model::DeleteBackupOutcomeCallable DeleteBackupCallable(const Model::DeleteBackupRequest& request) const; 995 996 /** 997 * <p>Deletes an existing backup of a table.</p> <p>You can call 998 * <code>DeleteBackup</code> at a maximum rate of 10 times per 999 * second.</p><p><h3>See Also:</h3> <a 1000 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DeleteBackup">AWS 1001 * API Reference</a></p> 1002 * 1003 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1004 */ 1005 virtual void DeleteBackupAsync(const Model::DeleteBackupRequest& request, const DeleteBackupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1006 1007 /** 1008 * <p>Deletes a single item in a table by primary key. You can perform a 1009 * conditional delete operation that deletes the item if it exists, or if it has an 1010 * expected attribute value.</p> <p>In addition to deleting an item, you can also 1011 * return the item's attribute values in the same operation, using the 1012 * <code>ReturnValues</code> parameter.</p> <p>Unless you specify conditions, the 1013 * <code>DeleteItem</code> is an idempotent operation; running it multiple times on 1014 * the same item or attribute does <i>not</i> result in an error response.</p> 1015 * <p>Conditional deletes are useful for deleting items only if specific conditions 1016 * are met. If those conditions are met, DynamoDB performs the delete. Otherwise, 1017 * the item is not deleted.</p><p><h3>See Also:</h3> <a 1018 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DeleteItem">AWS 1019 * API Reference</a></p> 1020 */ 1021 virtual Model::DeleteItemOutcome DeleteItem(const Model::DeleteItemRequest& request) const; 1022 1023 /** 1024 * <p>Deletes a single item in a table by primary key. You can perform a 1025 * conditional delete operation that deletes the item if it exists, or if it has an 1026 * expected attribute value.</p> <p>In addition to deleting an item, you can also 1027 * return the item's attribute values in the same operation, using the 1028 * <code>ReturnValues</code> parameter.</p> <p>Unless you specify conditions, the 1029 * <code>DeleteItem</code> is an idempotent operation; running it multiple times on 1030 * the same item or attribute does <i>not</i> result in an error response.</p> 1031 * <p>Conditional deletes are useful for deleting items only if specific conditions 1032 * are met. If those conditions are met, DynamoDB performs the delete. Otherwise, 1033 * the item is not deleted.</p><p><h3>See Also:</h3> <a 1034 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DeleteItem">AWS 1035 * API Reference</a></p> 1036 * 1037 * returns a future to the operation so that it can be executed in parallel to other requests. 1038 */ 1039 virtual Model::DeleteItemOutcomeCallable DeleteItemCallable(const Model::DeleteItemRequest& request) const; 1040 1041 /** 1042 * <p>Deletes a single item in a table by primary key. You can perform a 1043 * conditional delete operation that deletes the item if it exists, or if it has an 1044 * expected attribute value.</p> <p>In addition to deleting an item, you can also 1045 * return the item's attribute values in the same operation, using the 1046 * <code>ReturnValues</code> parameter.</p> <p>Unless you specify conditions, the 1047 * <code>DeleteItem</code> is an idempotent operation; running it multiple times on 1048 * the same item or attribute does <i>not</i> result in an error response.</p> 1049 * <p>Conditional deletes are useful for deleting items only if specific conditions 1050 * are met. If those conditions are met, DynamoDB performs the delete. Otherwise, 1051 * the item is not deleted.</p><p><h3>See Also:</h3> <a 1052 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DeleteItem">AWS 1053 * API Reference</a></p> 1054 * 1055 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1056 */ 1057 virtual void DeleteItemAsync(const Model::DeleteItemRequest& request, const DeleteItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1058 1059 /** 1060 * <p>The <code>DeleteTable</code> operation deletes a table and all of its items. 1061 * After a <code>DeleteTable</code> request, the specified table is in the 1062 * <code>DELETING</code> state until DynamoDB completes the deletion. If the table 1063 * is in the <code>ACTIVE</code> state, you can delete it. If a table is in 1064 * <code>CREATING</code> or <code>UPDATING</code> states, then DynamoDB returns a 1065 * <code>ResourceInUseException</code>. If the specified table does not exist, 1066 * DynamoDB returns a <code>ResourceNotFoundException</code>. If table is already 1067 * in the <code>DELETING</code> state, no error is returned. </p> 1068 * <p>DynamoDB might continue to accept data read and write operations, such as 1069 * <code>GetItem</code> and <code>PutItem</code>, on a table in the 1070 * <code>DELETING</code> state until the table deletion is complete.</p> 1071 * <p>When you delete a table, any indexes on that table are also deleted.</p> 1072 * <p>If you have DynamoDB Streams enabled on the table, then the corresponding 1073 * stream on that table goes into the <code>DISABLED</code> state, and the stream 1074 * is automatically deleted after 24 hours.</p> <p>Use the 1075 * <code>DescribeTable</code> action to check the status of the table. 1076 * </p><p><h3>See Also:</h3> <a 1077 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DeleteTable">AWS 1078 * API Reference</a></p> 1079 */ 1080 virtual Model::DeleteTableOutcome DeleteTable(const Model::DeleteTableRequest& request) const; 1081 1082 /** 1083 * <p>The <code>DeleteTable</code> operation deletes a table and all of its items. 1084 * After a <code>DeleteTable</code> request, the specified table is in the 1085 * <code>DELETING</code> state until DynamoDB completes the deletion. If the table 1086 * is in the <code>ACTIVE</code> state, you can delete it. If a table is in 1087 * <code>CREATING</code> or <code>UPDATING</code> states, then DynamoDB returns a 1088 * <code>ResourceInUseException</code>. If the specified table does not exist, 1089 * DynamoDB returns a <code>ResourceNotFoundException</code>. If table is already 1090 * in the <code>DELETING</code> state, no error is returned. </p> 1091 * <p>DynamoDB might continue to accept data read and write operations, such as 1092 * <code>GetItem</code> and <code>PutItem</code>, on a table in the 1093 * <code>DELETING</code> state until the table deletion is complete.</p> 1094 * <p>When you delete a table, any indexes on that table are also deleted.</p> 1095 * <p>If you have DynamoDB Streams enabled on the table, then the corresponding 1096 * stream on that table goes into the <code>DISABLED</code> state, and the stream 1097 * is automatically deleted after 24 hours.</p> <p>Use the 1098 * <code>DescribeTable</code> action to check the status of the table. 1099 * </p><p><h3>See Also:</h3> <a 1100 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DeleteTable">AWS 1101 * API Reference</a></p> 1102 * 1103 * returns a future to the operation so that it can be executed in parallel to other requests. 1104 */ 1105 virtual Model::DeleteTableOutcomeCallable DeleteTableCallable(const Model::DeleteTableRequest& request) const; 1106 1107 /** 1108 * <p>The <code>DeleteTable</code> operation deletes a table and all of its items. 1109 * After a <code>DeleteTable</code> request, the specified table is in the 1110 * <code>DELETING</code> state until DynamoDB completes the deletion. If the table 1111 * is in the <code>ACTIVE</code> state, you can delete it. If a table is in 1112 * <code>CREATING</code> or <code>UPDATING</code> states, then DynamoDB returns a 1113 * <code>ResourceInUseException</code>. If the specified table does not exist, 1114 * DynamoDB returns a <code>ResourceNotFoundException</code>. If table is already 1115 * in the <code>DELETING</code> state, no error is returned. </p> 1116 * <p>DynamoDB might continue to accept data read and write operations, such as 1117 * <code>GetItem</code> and <code>PutItem</code>, on a table in the 1118 * <code>DELETING</code> state until the table deletion is complete.</p> 1119 * <p>When you delete a table, any indexes on that table are also deleted.</p> 1120 * <p>If you have DynamoDB Streams enabled on the table, then the corresponding 1121 * stream on that table goes into the <code>DISABLED</code> state, and the stream 1122 * is automatically deleted after 24 hours.</p> <p>Use the 1123 * <code>DescribeTable</code> action to check the status of the table. 1124 * </p><p><h3>See Also:</h3> <a 1125 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DeleteTable">AWS 1126 * API Reference</a></p> 1127 * 1128 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1129 */ 1130 virtual void DeleteTableAsync(const Model::DeleteTableRequest& request, const DeleteTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1131 1132 /** 1133 * <p>Describes an existing backup of a table.</p> <p>You can call 1134 * <code>DescribeBackup</code> at a maximum rate of 10 times per 1135 * second.</p><p><h3>See Also:</h3> <a 1136 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeBackup">AWS 1137 * API Reference</a></p> 1138 */ 1139 virtual Model::DescribeBackupOutcome DescribeBackup(const Model::DescribeBackupRequest& request) const; 1140 1141 /** 1142 * <p>Describes an existing backup of a table.</p> <p>You can call 1143 * <code>DescribeBackup</code> at a maximum rate of 10 times per 1144 * second.</p><p><h3>See Also:</h3> <a 1145 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeBackup">AWS 1146 * API Reference</a></p> 1147 * 1148 * returns a future to the operation so that it can be executed in parallel to other requests. 1149 */ 1150 virtual Model::DescribeBackupOutcomeCallable DescribeBackupCallable(const Model::DescribeBackupRequest& request) const; 1151 1152 /** 1153 * <p>Describes an existing backup of a table.</p> <p>You can call 1154 * <code>DescribeBackup</code> at a maximum rate of 10 times per 1155 * second.</p><p><h3>See Also:</h3> <a 1156 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeBackup">AWS 1157 * API Reference</a></p> 1158 * 1159 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1160 */ 1161 virtual void DescribeBackupAsync(const Model::DescribeBackupRequest& request, const DescribeBackupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1162 1163 /** 1164 * <p>Checks the status of continuous backups and point in time recovery on the 1165 * specified table. Continuous backups are <code>ENABLED</code> on all tables at 1166 * table creation. If point in time recovery is enabled, 1167 * <code>PointInTimeRecoveryStatus</code> will be set to ENABLED.</p> <p> After 1168 * continuous backups and point in time recovery are enabled, you can restore to 1169 * any point in time within <code>EarliestRestorableDateTime</code> and 1170 * <code>LatestRestorableDateTime</code>. </p> <p> 1171 * <code>LatestRestorableDateTime</code> is typically 5 minutes before the current 1172 * time. You can restore your table to any point in time during the last 35 days. 1173 * </p> <p>You can call <code>DescribeContinuousBackups</code> at a maximum rate of 1174 * 10 times per second.</p><p><h3>See Also:</h3> <a 1175 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeContinuousBackups">AWS 1176 * API Reference</a></p> 1177 */ 1178 virtual Model::DescribeContinuousBackupsOutcome DescribeContinuousBackups(const Model::DescribeContinuousBackupsRequest& request) const; 1179 1180 /** 1181 * <p>Checks the status of continuous backups and point in time recovery on the 1182 * specified table. Continuous backups are <code>ENABLED</code> on all tables at 1183 * table creation. If point in time recovery is enabled, 1184 * <code>PointInTimeRecoveryStatus</code> will be set to ENABLED.</p> <p> After 1185 * continuous backups and point in time recovery are enabled, you can restore to 1186 * any point in time within <code>EarliestRestorableDateTime</code> and 1187 * <code>LatestRestorableDateTime</code>. </p> <p> 1188 * <code>LatestRestorableDateTime</code> is typically 5 minutes before the current 1189 * time. You can restore your table to any point in time during the last 35 days. 1190 * </p> <p>You can call <code>DescribeContinuousBackups</code> at a maximum rate of 1191 * 10 times per second.</p><p><h3>See Also:</h3> <a 1192 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeContinuousBackups">AWS 1193 * API Reference</a></p> 1194 * 1195 * returns a future to the operation so that it can be executed in parallel to other requests. 1196 */ 1197 virtual Model::DescribeContinuousBackupsOutcomeCallable DescribeContinuousBackupsCallable(const Model::DescribeContinuousBackupsRequest& request) const; 1198 1199 /** 1200 * <p>Checks the status of continuous backups and point in time recovery on the 1201 * specified table. Continuous backups are <code>ENABLED</code> on all tables at 1202 * table creation. If point in time recovery is enabled, 1203 * <code>PointInTimeRecoveryStatus</code> will be set to ENABLED.</p> <p> After 1204 * continuous backups and point in time recovery are enabled, you can restore to 1205 * any point in time within <code>EarliestRestorableDateTime</code> and 1206 * <code>LatestRestorableDateTime</code>. </p> <p> 1207 * <code>LatestRestorableDateTime</code> is typically 5 minutes before the current 1208 * time. You can restore your table to any point in time during the last 35 days. 1209 * </p> <p>You can call <code>DescribeContinuousBackups</code> at a maximum rate of 1210 * 10 times per second.</p><p><h3>See Also:</h3> <a 1211 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeContinuousBackups">AWS 1212 * API Reference</a></p> 1213 * 1214 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1215 */ 1216 virtual void DescribeContinuousBackupsAsync(const Model::DescribeContinuousBackupsRequest& request, const DescribeContinuousBackupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1217 1218 /** 1219 * <p>Returns information about contributor insights, for a given table or global 1220 * secondary index.</p><p><h3>See Also:</h3> <a 1221 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeContributorInsights">AWS 1222 * API Reference</a></p> 1223 */ 1224 virtual Model::DescribeContributorInsightsOutcome DescribeContributorInsights(const Model::DescribeContributorInsightsRequest& request) const; 1225 1226 /** 1227 * <p>Returns information about contributor insights, for a given table or global 1228 * secondary index.</p><p><h3>See Also:</h3> <a 1229 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeContributorInsights">AWS 1230 * API Reference</a></p> 1231 * 1232 * returns a future to the operation so that it can be executed in parallel to other requests. 1233 */ 1234 virtual Model::DescribeContributorInsightsOutcomeCallable DescribeContributorInsightsCallable(const Model::DescribeContributorInsightsRequest& request) const; 1235 1236 /** 1237 * <p>Returns information about contributor insights, for a given table or global 1238 * secondary index.</p><p><h3>See Also:</h3> <a 1239 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeContributorInsights">AWS 1240 * API Reference</a></p> 1241 * 1242 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1243 */ 1244 virtual void DescribeContributorInsightsAsync(const Model::DescribeContributorInsightsRequest& request, const DescribeContributorInsightsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1245 1246 /** 1247 * <p>Returns the regional endpoint information.</p><p><h3>See Also:</h3> <a 1248 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeEndpoints">AWS 1249 * API Reference</a></p> 1250 */ 1251 virtual Model::DescribeEndpointsOutcome DescribeEndpoints(const Model::DescribeEndpointsRequest& request) const; 1252 1253 /** 1254 * <p>Returns the regional endpoint information.</p><p><h3>See Also:</h3> <a 1255 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeEndpoints">AWS 1256 * API Reference</a></p> 1257 * 1258 * returns a future to the operation so that it can be executed in parallel to other requests. 1259 */ 1260 virtual Model::DescribeEndpointsOutcomeCallable DescribeEndpointsCallable(const Model::DescribeEndpointsRequest& request) const; 1261 1262 /** 1263 * <p>Returns the regional endpoint information.</p><p><h3>See Also:</h3> <a 1264 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeEndpoints">AWS 1265 * API Reference</a></p> 1266 * 1267 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1268 */ 1269 virtual void DescribeEndpointsAsync(const Model::DescribeEndpointsRequest& request, const DescribeEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1270 1271 /** 1272 * <p>Describes an existing table export.</p><p><h3>See Also:</h3> <a 1273 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeExport">AWS 1274 * API Reference</a></p> 1275 */ 1276 virtual Model::DescribeExportOutcome DescribeExport(const Model::DescribeExportRequest& request) const; 1277 1278 /** 1279 * <p>Describes an existing table export.</p><p><h3>See Also:</h3> <a 1280 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeExport">AWS 1281 * API Reference</a></p> 1282 * 1283 * returns a future to the operation so that it can be executed in parallel to other requests. 1284 */ 1285 virtual Model::DescribeExportOutcomeCallable DescribeExportCallable(const Model::DescribeExportRequest& request) const; 1286 1287 /** 1288 * <p>Describes an existing table export.</p><p><h3>See Also:</h3> <a 1289 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeExport">AWS 1290 * API Reference</a></p> 1291 * 1292 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1293 */ 1294 virtual void DescribeExportAsync(const Model::DescribeExportRequest& request, const DescribeExportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1295 1296 /** 1297 * <p>Returns information about the specified global table.</p> <p>This 1298 * operation only applies to <a 1299 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html">Version 1300 * 2017.11.29</a> of global tables. If you are using global tables <a 1301 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 1302 * 2019.11.21</a> you can use <a 1303 * href="https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html">DescribeTable</a> 1304 * instead.</p> <p><h3>See Also:</h3> <a 1305 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeGlobalTable">AWS 1306 * API Reference</a></p> 1307 */ 1308 virtual Model::DescribeGlobalTableOutcome DescribeGlobalTable(const Model::DescribeGlobalTableRequest& request) const; 1309 1310 /** 1311 * <p>Returns information about the specified global table.</p> <p>This 1312 * operation only applies to <a 1313 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html">Version 1314 * 2017.11.29</a> of global tables. If you are using global tables <a 1315 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 1316 * 2019.11.21</a> you can use <a 1317 * href="https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html">DescribeTable</a> 1318 * instead.</p> <p><h3>See Also:</h3> <a 1319 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeGlobalTable">AWS 1320 * API Reference</a></p> 1321 * 1322 * returns a future to the operation so that it can be executed in parallel to other requests. 1323 */ 1324 virtual Model::DescribeGlobalTableOutcomeCallable DescribeGlobalTableCallable(const Model::DescribeGlobalTableRequest& request) const; 1325 1326 /** 1327 * <p>Returns information about the specified global table.</p> <p>This 1328 * operation only applies to <a 1329 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html">Version 1330 * 2017.11.29</a> of global tables. If you are using global tables <a 1331 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 1332 * 2019.11.21</a> you can use <a 1333 * href="https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html">DescribeTable</a> 1334 * instead.</p> <p><h3>See Also:</h3> <a 1335 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeGlobalTable">AWS 1336 * API Reference</a></p> 1337 * 1338 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1339 */ 1340 virtual void DescribeGlobalTableAsync(const Model::DescribeGlobalTableRequest& request, const DescribeGlobalTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1341 1342 /** 1343 * <p>Describes Region-specific settings for a global table.</p> <p>This 1344 * operation only applies to <a 1345 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html">Version 1346 * 2017.11.29</a> of global tables.</p> <p><h3>See Also:</h3> <a 1347 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeGlobalTableSettings">AWS 1348 * API Reference</a></p> 1349 */ 1350 virtual Model::DescribeGlobalTableSettingsOutcome DescribeGlobalTableSettings(const Model::DescribeGlobalTableSettingsRequest& request) const; 1351 1352 /** 1353 * <p>Describes Region-specific settings for a global table.</p> <p>This 1354 * operation only applies to <a 1355 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html">Version 1356 * 2017.11.29</a> of global tables.</p> <p><h3>See Also:</h3> <a 1357 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeGlobalTableSettings">AWS 1358 * API Reference</a></p> 1359 * 1360 * returns a future to the operation so that it can be executed in parallel to other requests. 1361 */ 1362 virtual Model::DescribeGlobalTableSettingsOutcomeCallable DescribeGlobalTableSettingsCallable(const Model::DescribeGlobalTableSettingsRequest& request) const; 1363 1364 /** 1365 * <p>Describes Region-specific settings for a global table.</p> <p>This 1366 * operation only applies to <a 1367 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html">Version 1368 * 2017.11.29</a> of global tables.</p> <p><h3>See Also:</h3> <a 1369 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeGlobalTableSettings">AWS 1370 * API Reference</a></p> 1371 * 1372 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1373 */ 1374 virtual void DescribeGlobalTableSettingsAsync(const Model::DescribeGlobalTableSettingsRequest& request, const DescribeGlobalTableSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1375 1376 /** 1377 * <p>Returns information about the status of Kinesis streaming.</p><p><h3>See 1378 * Also:</h3> <a 1379 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeKinesisStreamingDestination">AWS 1380 * API Reference</a></p> 1381 */ 1382 virtual Model::DescribeKinesisStreamingDestinationOutcome DescribeKinesisStreamingDestination(const Model::DescribeKinesisStreamingDestinationRequest& request) const; 1383 1384 /** 1385 * <p>Returns information about the status of Kinesis streaming.</p><p><h3>See 1386 * Also:</h3> <a 1387 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeKinesisStreamingDestination">AWS 1388 * API Reference</a></p> 1389 * 1390 * returns a future to the operation so that it can be executed in parallel to other requests. 1391 */ 1392 virtual Model::DescribeKinesisStreamingDestinationOutcomeCallable DescribeKinesisStreamingDestinationCallable(const Model::DescribeKinesisStreamingDestinationRequest& request) const; 1393 1394 /** 1395 * <p>Returns information about the status of Kinesis streaming.</p><p><h3>See 1396 * Also:</h3> <a 1397 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeKinesisStreamingDestination">AWS 1398 * API Reference</a></p> 1399 * 1400 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1401 */ 1402 virtual void DescribeKinesisStreamingDestinationAsync(const Model::DescribeKinesisStreamingDestinationRequest& request, const DescribeKinesisStreamingDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1403 1404 /** 1405 * <p>Returns the current provisioned-capacity quotas for your AWS account in a 1406 * Region, both for the Region as a whole and for any one DynamoDB table that you 1407 * create there.</p> <p>When you establish an AWS account, the account has initial 1408 * quotas on the maximum read capacity units and write capacity units that you can 1409 * provision across all of your DynamoDB tables in a given Region. Also, there are 1410 * per-table quotas that apply when you create a table there. For more information, 1411 * see <a 1412 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Service, 1413 * Account, and Table Quotas</a> page in the <i>Amazon DynamoDB Developer 1414 * Guide</i>.</p> <p>Although you can increase these quotas by filing a case at <a 1415 * href="https://console.aws.amazon.com/support/home#/">AWS Support Center</a>, 1416 * obtaining the increase is not instantaneous. The <code>DescribeLimits</code> 1417 * action lets you write code to compare the capacity you are currently using to 1418 * those quotas imposed by your account so that you have enough time to apply for 1419 * an increase before you hit a quota.</p> <p>For example, you could use one of the 1420 * AWS SDKs to do the following:</p> <ol> <li> <p>Call <code>DescribeLimits</code> 1421 * for a particular Region to obtain your current account quotas on provisioned 1422 * capacity there.</p> </li> <li> <p>Create a variable to hold the aggregate read 1423 * capacity units provisioned for all your tables in that Region, and one to hold 1424 * the aggregate write capacity units. Zero them both.</p> </li> <li> <p>Call 1425 * <code>ListTables</code> to obtain a list of all your DynamoDB tables.</p> </li> 1426 * <li> <p>For each table name listed by <code>ListTables</code>, do the 1427 * following:</p> <ul> <li> <p>Call <code>DescribeTable</code> with the table 1428 * name.</p> </li> <li> <p>Use the data returned by <code>DescribeTable</code> to 1429 * add the read capacity units and write capacity units provisioned for the table 1430 * itself to your variables.</p> </li> <li> <p>If the table has one or more global 1431 * secondary indexes (GSIs), loop over these GSIs and add their provisioned 1432 * capacity values to your variables as well.</p> </li> </ul> </li> <li> <p>Report 1433 * the account quotas for that Region returned by <code>DescribeLimits</code>, 1434 * along with the total current provisioned capacity levels you have 1435 * calculated.</p> </li> </ol> <p>This will let you see whether you are getting 1436 * close to your account-level quotas.</p> <p>The per-table quotas apply only when 1437 * you are creating a new table. They restrict the sum of the provisioned capacity 1438 * of the new table itself and all its global secondary indexes.</p> <p>For 1439 * existing tables and their GSIs, DynamoDB doesn't let you increase provisioned 1440 * capacity extremely rapidly, but the only quota that applies is that the 1441 * aggregate provisioned capacity over all your tables and GSIs cannot exceed 1442 * either of the per-account quotas.</p> <p> <code>DescribeLimits</code> 1443 * should only be called periodically. You can expect throttling errors if you call 1444 * it more than once in a minute.</p> <p>The <code>DescribeLimits</code> 1445 * Request element has no content.</p><p><h3>See Also:</h3> <a 1446 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeLimits">AWS 1447 * API Reference</a></p> 1448 */ 1449 virtual Model::DescribeLimitsOutcome DescribeLimits(const Model::DescribeLimitsRequest& request) const; 1450 1451 /** 1452 * <p>Returns the current provisioned-capacity quotas for your AWS account in a 1453 * Region, both for the Region as a whole and for any one DynamoDB table that you 1454 * create there.</p> <p>When you establish an AWS account, the account has initial 1455 * quotas on the maximum read capacity units and write capacity units that you can 1456 * provision across all of your DynamoDB tables in a given Region. Also, there are 1457 * per-table quotas that apply when you create a table there. For more information, 1458 * see <a 1459 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Service, 1460 * Account, and Table Quotas</a> page in the <i>Amazon DynamoDB Developer 1461 * Guide</i>.</p> <p>Although you can increase these quotas by filing a case at <a 1462 * href="https://console.aws.amazon.com/support/home#/">AWS Support Center</a>, 1463 * obtaining the increase is not instantaneous. The <code>DescribeLimits</code> 1464 * action lets you write code to compare the capacity you are currently using to 1465 * those quotas imposed by your account so that you have enough time to apply for 1466 * an increase before you hit a quota.</p> <p>For example, you could use one of the 1467 * AWS SDKs to do the following:</p> <ol> <li> <p>Call <code>DescribeLimits</code> 1468 * for a particular Region to obtain your current account quotas on provisioned 1469 * capacity there.</p> </li> <li> <p>Create a variable to hold the aggregate read 1470 * capacity units provisioned for all your tables in that Region, and one to hold 1471 * the aggregate write capacity units. Zero them both.</p> </li> <li> <p>Call 1472 * <code>ListTables</code> to obtain a list of all your DynamoDB tables.</p> </li> 1473 * <li> <p>For each table name listed by <code>ListTables</code>, do the 1474 * following:</p> <ul> <li> <p>Call <code>DescribeTable</code> with the table 1475 * name.</p> </li> <li> <p>Use the data returned by <code>DescribeTable</code> to 1476 * add the read capacity units and write capacity units provisioned for the table 1477 * itself to your variables.</p> </li> <li> <p>If the table has one or more global 1478 * secondary indexes (GSIs), loop over these GSIs and add their provisioned 1479 * capacity values to your variables as well.</p> </li> </ul> </li> <li> <p>Report 1480 * the account quotas for that Region returned by <code>DescribeLimits</code>, 1481 * along with the total current provisioned capacity levels you have 1482 * calculated.</p> </li> </ol> <p>This will let you see whether you are getting 1483 * close to your account-level quotas.</p> <p>The per-table quotas apply only when 1484 * you are creating a new table. They restrict the sum of the provisioned capacity 1485 * of the new table itself and all its global secondary indexes.</p> <p>For 1486 * existing tables and their GSIs, DynamoDB doesn't let you increase provisioned 1487 * capacity extremely rapidly, but the only quota that applies is that the 1488 * aggregate provisioned capacity over all your tables and GSIs cannot exceed 1489 * either of the per-account quotas.</p> <p> <code>DescribeLimits</code> 1490 * should only be called periodically. You can expect throttling errors if you call 1491 * it more than once in a minute.</p> <p>The <code>DescribeLimits</code> 1492 * Request element has no content.</p><p><h3>See Also:</h3> <a 1493 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeLimits">AWS 1494 * API Reference</a></p> 1495 * 1496 * returns a future to the operation so that it can be executed in parallel to other requests. 1497 */ 1498 virtual Model::DescribeLimitsOutcomeCallable DescribeLimitsCallable(const Model::DescribeLimitsRequest& request) const; 1499 1500 /** 1501 * <p>Returns the current provisioned-capacity quotas for your AWS account in a 1502 * Region, both for the Region as a whole and for any one DynamoDB table that you 1503 * create there.</p> <p>When you establish an AWS account, the account has initial 1504 * quotas on the maximum read capacity units and write capacity units that you can 1505 * provision across all of your DynamoDB tables in a given Region. Also, there are 1506 * per-table quotas that apply when you create a table there. For more information, 1507 * see <a 1508 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html">Service, 1509 * Account, and Table Quotas</a> page in the <i>Amazon DynamoDB Developer 1510 * Guide</i>.</p> <p>Although you can increase these quotas by filing a case at <a 1511 * href="https://console.aws.amazon.com/support/home#/">AWS Support Center</a>, 1512 * obtaining the increase is not instantaneous. The <code>DescribeLimits</code> 1513 * action lets you write code to compare the capacity you are currently using to 1514 * those quotas imposed by your account so that you have enough time to apply for 1515 * an increase before you hit a quota.</p> <p>For example, you could use one of the 1516 * AWS SDKs to do the following:</p> <ol> <li> <p>Call <code>DescribeLimits</code> 1517 * for a particular Region to obtain your current account quotas on provisioned 1518 * capacity there.</p> </li> <li> <p>Create a variable to hold the aggregate read 1519 * capacity units provisioned for all your tables in that Region, and one to hold 1520 * the aggregate write capacity units. Zero them both.</p> </li> <li> <p>Call 1521 * <code>ListTables</code> to obtain a list of all your DynamoDB tables.</p> </li> 1522 * <li> <p>For each table name listed by <code>ListTables</code>, do the 1523 * following:</p> <ul> <li> <p>Call <code>DescribeTable</code> with the table 1524 * name.</p> </li> <li> <p>Use the data returned by <code>DescribeTable</code> to 1525 * add the read capacity units and write capacity units provisioned for the table 1526 * itself to your variables.</p> </li> <li> <p>If the table has one or more global 1527 * secondary indexes (GSIs), loop over these GSIs and add their provisioned 1528 * capacity values to your variables as well.</p> </li> </ul> </li> <li> <p>Report 1529 * the account quotas for that Region returned by <code>DescribeLimits</code>, 1530 * along with the total current provisioned capacity levels you have 1531 * calculated.</p> </li> </ol> <p>This will let you see whether you are getting 1532 * close to your account-level quotas.</p> <p>The per-table quotas apply only when 1533 * you are creating a new table. They restrict the sum of the provisioned capacity 1534 * of the new table itself and all its global secondary indexes.</p> <p>For 1535 * existing tables and their GSIs, DynamoDB doesn't let you increase provisioned 1536 * capacity extremely rapidly, but the only quota that applies is that the 1537 * aggregate provisioned capacity over all your tables and GSIs cannot exceed 1538 * either of the per-account quotas.</p> <p> <code>DescribeLimits</code> 1539 * should only be called periodically. You can expect throttling errors if you call 1540 * it more than once in a minute.</p> <p>The <code>DescribeLimits</code> 1541 * Request element has no content.</p><p><h3>See Also:</h3> <a 1542 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeLimits">AWS 1543 * API Reference</a></p> 1544 * 1545 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1546 */ 1547 virtual void DescribeLimitsAsync(const Model::DescribeLimitsRequest& request, const DescribeLimitsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1548 1549 /** 1550 * <p>Returns information about the table, including the current status of the 1551 * table, when it was created, the primary key schema, and any indexes on the 1552 * table.</p> <p>If you issue a <code>DescribeTable</code> request 1553 * immediately after a <code>CreateTable</code> request, DynamoDB might return a 1554 * <code>ResourceNotFoundException</code>. This is because 1555 * <code>DescribeTable</code> uses an eventually consistent query, and the metadata 1556 * for your table might not be available at that moment. Wait for a few seconds, 1557 * and then try the <code>DescribeTable</code> request again.</p> <p><h3>See 1558 * Also:</h3> <a 1559 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeTable">AWS 1560 * API Reference</a></p> 1561 */ 1562 virtual Model::DescribeTableOutcome DescribeTable(const Model::DescribeTableRequest& request) const; 1563 1564 /** 1565 * <p>Returns information about the table, including the current status of the 1566 * table, when it was created, the primary key schema, and any indexes on the 1567 * table.</p> <p>If you issue a <code>DescribeTable</code> request 1568 * immediately after a <code>CreateTable</code> request, DynamoDB might return a 1569 * <code>ResourceNotFoundException</code>. This is because 1570 * <code>DescribeTable</code> uses an eventually consistent query, and the metadata 1571 * for your table might not be available at that moment. Wait for a few seconds, 1572 * and then try the <code>DescribeTable</code> request again.</p> <p><h3>See 1573 * Also:</h3> <a 1574 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeTable">AWS 1575 * API Reference</a></p> 1576 * 1577 * returns a future to the operation so that it can be executed in parallel to other requests. 1578 */ 1579 virtual Model::DescribeTableOutcomeCallable DescribeTableCallable(const Model::DescribeTableRequest& request) const; 1580 1581 /** 1582 * <p>Returns information about the table, including the current status of the 1583 * table, when it was created, the primary key schema, and any indexes on the 1584 * table.</p> <p>If you issue a <code>DescribeTable</code> request 1585 * immediately after a <code>CreateTable</code> request, DynamoDB might return a 1586 * <code>ResourceNotFoundException</code>. This is because 1587 * <code>DescribeTable</code> uses an eventually consistent query, and the metadata 1588 * for your table might not be available at that moment. Wait for a few seconds, 1589 * and then try the <code>DescribeTable</code> request again.</p> <p><h3>See 1590 * Also:</h3> <a 1591 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeTable">AWS 1592 * API Reference</a></p> 1593 * 1594 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1595 */ 1596 virtual void DescribeTableAsync(const Model::DescribeTableRequest& request, const DescribeTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1597 1598 /** 1599 * <p>Describes auto scaling settings across replicas of the global table at 1600 * once.</p> <p>This operation only applies to <a 1601 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 1602 * 2019.11.21</a> of global tables.</p> <p><h3>See Also:</h3> <a 1603 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeTableReplicaAutoScaling">AWS 1604 * API Reference</a></p> 1605 */ 1606 virtual Model::DescribeTableReplicaAutoScalingOutcome DescribeTableReplicaAutoScaling(const Model::DescribeTableReplicaAutoScalingRequest& request) const; 1607 1608 /** 1609 * <p>Describes auto scaling settings across replicas of the global table at 1610 * once.</p> <p>This operation only applies to <a 1611 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 1612 * 2019.11.21</a> of global tables.</p> <p><h3>See Also:</h3> <a 1613 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeTableReplicaAutoScaling">AWS 1614 * API Reference</a></p> 1615 * 1616 * returns a future to the operation so that it can be executed in parallel to other requests. 1617 */ 1618 virtual Model::DescribeTableReplicaAutoScalingOutcomeCallable DescribeTableReplicaAutoScalingCallable(const Model::DescribeTableReplicaAutoScalingRequest& request) const; 1619 1620 /** 1621 * <p>Describes auto scaling settings across replicas of the global table at 1622 * once.</p> <p>This operation only applies to <a 1623 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 1624 * 2019.11.21</a> of global tables.</p> <p><h3>See Also:</h3> <a 1625 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeTableReplicaAutoScaling">AWS 1626 * API Reference</a></p> 1627 * 1628 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1629 */ 1630 virtual void DescribeTableReplicaAutoScalingAsync(const Model::DescribeTableReplicaAutoScalingRequest& request, const DescribeTableReplicaAutoScalingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1631 1632 /** 1633 * <p>Gives a description of the Time to Live (TTL) status on the specified table. 1634 * </p><p><h3>See Also:</h3> <a 1635 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeTimeToLive">AWS 1636 * API Reference</a></p> 1637 */ 1638 virtual Model::DescribeTimeToLiveOutcome DescribeTimeToLive(const Model::DescribeTimeToLiveRequest& request) const; 1639 1640 /** 1641 * <p>Gives a description of the Time to Live (TTL) status on the specified table. 1642 * </p><p><h3>See Also:</h3> <a 1643 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeTimeToLive">AWS 1644 * API Reference</a></p> 1645 * 1646 * returns a future to the operation so that it can be executed in parallel to other requests. 1647 */ 1648 virtual Model::DescribeTimeToLiveOutcomeCallable DescribeTimeToLiveCallable(const Model::DescribeTimeToLiveRequest& request) const; 1649 1650 /** 1651 * <p>Gives a description of the Time to Live (TTL) status on the specified table. 1652 * </p><p><h3>See Also:</h3> <a 1653 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DescribeTimeToLive">AWS 1654 * API Reference</a></p> 1655 * 1656 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1657 */ 1658 virtual void DescribeTimeToLiveAsync(const Model::DescribeTimeToLiveRequest& request, const DescribeTimeToLiveResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1659 1660 /** 1661 * <p>Stops replication from the DynamoDB table to the Kinesis data stream. This is 1662 * done without deleting either of the resources.</p><p><h3>See Also:</h3> <a 1663 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DisableKinesisStreamingDestination">AWS 1664 * API Reference</a></p> 1665 */ 1666 virtual Model::DisableKinesisStreamingDestinationOutcome DisableKinesisStreamingDestination(const Model::DisableKinesisStreamingDestinationRequest& request) const; 1667 1668 /** 1669 * <p>Stops replication from the DynamoDB table to the Kinesis data stream. This is 1670 * done without deleting either of the resources.</p><p><h3>See Also:</h3> <a 1671 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DisableKinesisStreamingDestination">AWS 1672 * API Reference</a></p> 1673 * 1674 * returns a future to the operation so that it can be executed in parallel to other requests. 1675 */ 1676 virtual Model::DisableKinesisStreamingDestinationOutcomeCallable DisableKinesisStreamingDestinationCallable(const Model::DisableKinesisStreamingDestinationRequest& request) const; 1677 1678 /** 1679 * <p>Stops replication from the DynamoDB table to the Kinesis data stream. This is 1680 * done without deleting either of the resources.</p><p><h3>See Also:</h3> <a 1681 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/DisableKinesisStreamingDestination">AWS 1682 * API Reference</a></p> 1683 * 1684 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1685 */ 1686 virtual void DisableKinesisStreamingDestinationAsync(const Model::DisableKinesisStreamingDestinationRequest& request, const DisableKinesisStreamingDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1687 1688 /** 1689 * <p>Starts table data replication to the specified Kinesis data stream at a 1690 * timestamp chosen during the enable workflow. If this operation doesn't return 1691 * results immediately, use DescribeKinesisStreamingDestination to check if 1692 * streaming to the Kinesis data stream is ACTIVE.</p><p><h3>See Also:</h3> <a 1693 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/EnableKinesisStreamingDestination">AWS 1694 * API Reference</a></p> 1695 */ 1696 virtual Model::EnableKinesisStreamingDestinationOutcome EnableKinesisStreamingDestination(const Model::EnableKinesisStreamingDestinationRequest& request) const; 1697 1698 /** 1699 * <p>Starts table data replication to the specified Kinesis data stream at a 1700 * timestamp chosen during the enable workflow. If this operation doesn't return 1701 * results immediately, use DescribeKinesisStreamingDestination to check if 1702 * streaming to the Kinesis data stream is ACTIVE.</p><p><h3>See Also:</h3> <a 1703 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/EnableKinesisStreamingDestination">AWS 1704 * API Reference</a></p> 1705 * 1706 * returns a future to the operation so that it can be executed in parallel to other requests. 1707 */ 1708 virtual Model::EnableKinesisStreamingDestinationOutcomeCallable EnableKinesisStreamingDestinationCallable(const Model::EnableKinesisStreamingDestinationRequest& request) const; 1709 1710 /** 1711 * <p>Starts table data replication to the specified Kinesis data stream at a 1712 * timestamp chosen during the enable workflow. If this operation doesn't return 1713 * results immediately, use DescribeKinesisStreamingDestination to check if 1714 * streaming to the Kinesis data stream is ACTIVE.</p><p><h3>See Also:</h3> <a 1715 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/EnableKinesisStreamingDestination">AWS 1716 * API Reference</a></p> 1717 * 1718 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1719 */ 1720 virtual void EnableKinesisStreamingDestinationAsync(const Model::EnableKinesisStreamingDestinationRequest& request, const EnableKinesisStreamingDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1721 1722 /** 1723 * <p> This operation allows you to perform reads and singleton writes on data 1724 * stored in DynamoDB, using PartiQL. </p><p><h3>See Also:</h3> <a 1725 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ExecuteStatement">AWS 1726 * API Reference</a></p> 1727 */ 1728 virtual Model::ExecuteStatementOutcome ExecuteStatement(const Model::ExecuteStatementRequest& request) const; 1729 1730 /** 1731 * <p> This operation allows you to perform reads and singleton writes on data 1732 * stored in DynamoDB, using PartiQL. </p><p><h3>See Also:</h3> <a 1733 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ExecuteStatement">AWS 1734 * API Reference</a></p> 1735 * 1736 * returns a future to the operation so that it can be executed in parallel to other requests. 1737 */ 1738 virtual Model::ExecuteStatementOutcomeCallable ExecuteStatementCallable(const Model::ExecuteStatementRequest& request) const; 1739 1740 /** 1741 * <p> This operation allows you to perform reads and singleton writes on data 1742 * stored in DynamoDB, using PartiQL. </p><p><h3>See Also:</h3> <a 1743 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ExecuteStatement">AWS 1744 * API Reference</a></p> 1745 * 1746 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1747 */ 1748 virtual void ExecuteStatementAsync(const Model::ExecuteStatementRequest& request, const ExecuteStatementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1749 1750 /** 1751 * <p> This operation allows you to perform transactional reads or writes on data 1752 * stored in DynamoDB, using PartiQL. </p><p><h3>See Also:</h3> <a 1753 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ExecuteTransaction">AWS 1754 * API Reference</a></p> 1755 */ 1756 virtual Model::ExecuteTransactionOutcome ExecuteTransaction(const Model::ExecuteTransactionRequest& request) const; 1757 1758 /** 1759 * <p> This operation allows you to perform transactional reads or writes on data 1760 * stored in DynamoDB, using PartiQL. </p><p><h3>See Also:</h3> <a 1761 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ExecuteTransaction">AWS 1762 * API Reference</a></p> 1763 * 1764 * returns a future to the operation so that it can be executed in parallel to other requests. 1765 */ 1766 virtual Model::ExecuteTransactionOutcomeCallable ExecuteTransactionCallable(const Model::ExecuteTransactionRequest& request) const; 1767 1768 /** 1769 * <p> This operation allows you to perform transactional reads or writes on data 1770 * stored in DynamoDB, using PartiQL. </p><p><h3>See Also:</h3> <a 1771 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ExecuteTransaction">AWS 1772 * API Reference</a></p> 1773 * 1774 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1775 */ 1776 virtual void ExecuteTransactionAsync(const Model::ExecuteTransactionRequest& request, const ExecuteTransactionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1777 1778 /** 1779 * <p>Exports table data to an S3 bucket. The table must have point in time 1780 * recovery enabled, and you can export data from any time within the point in time 1781 * recovery window.</p><p><h3>See Also:</h3> <a 1782 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ExportTableToPointInTime">AWS 1783 * API Reference</a></p> 1784 */ 1785 virtual Model::ExportTableToPointInTimeOutcome ExportTableToPointInTime(const Model::ExportTableToPointInTimeRequest& request) const; 1786 1787 /** 1788 * <p>Exports table data to an S3 bucket. The table must have point in time 1789 * recovery enabled, and you can export data from any time within the point in time 1790 * recovery window.</p><p><h3>See Also:</h3> <a 1791 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ExportTableToPointInTime">AWS 1792 * API Reference</a></p> 1793 * 1794 * returns a future to the operation so that it can be executed in parallel to other requests. 1795 */ 1796 virtual Model::ExportTableToPointInTimeOutcomeCallable ExportTableToPointInTimeCallable(const Model::ExportTableToPointInTimeRequest& request) const; 1797 1798 /** 1799 * <p>Exports table data to an S3 bucket. The table must have point in time 1800 * recovery enabled, and you can export data from any time within the point in time 1801 * recovery window.</p><p><h3>See Also:</h3> <a 1802 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ExportTableToPointInTime">AWS 1803 * API Reference</a></p> 1804 * 1805 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1806 */ 1807 virtual void ExportTableToPointInTimeAsync(const Model::ExportTableToPointInTimeRequest& request, const ExportTableToPointInTimeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1808 1809 /** 1810 * <p>The <code>GetItem</code> operation returns a set of attributes for the item 1811 * with the given primary key. If there is no matching item, <code>GetItem</code> 1812 * does not return any data and there will be no <code>Item</code> element in the 1813 * response.</p> <p> <code>GetItem</code> provides an eventually consistent read by 1814 * default. If your application requires a strongly consistent read, set 1815 * <code>ConsistentRead</code> to <code>true</code>. Although a strongly consistent 1816 * read might take more time than an eventually consistent read, it always returns 1817 * the last updated value.</p><p><h3>See Also:</h3> <a 1818 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/GetItem">AWS 1819 * API Reference</a></p> 1820 */ 1821 virtual Model::GetItemOutcome GetItem(const Model::GetItemRequest& request) const; 1822 1823 /** 1824 * <p>The <code>GetItem</code> operation returns a set of attributes for the item 1825 * with the given primary key. If there is no matching item, <code>GetItem</code> 1826 * does not return any data and there will be no <code>Item</code> element in the 1827 * response.</p> <p> <code>GetItem</code> provides an eventually consistent read by 1828 * default. If your application requires a strongly consistent read, set 1829 * <code>ConsistentRead</code> to <code>true</code>. Although a strongly consistent 1830 * read might take more time than an eventually consistent read, it always returns 1831 * the last updated value.</p><p><h3>See Also:</h3> <a 1832 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/GetItem">AWS 1833 * API Reference</a></p> 1834 * 1835 * returns a future to the operation so that it can be executed in parallel to other requests. 1836 */ 1837 virtual Model::GetItemOutcomeCallable GetItemCallable(const Model::GetItemRequest& request) const; 1838 1839 /** 1840 * <p>The <code>GetItem</code> operation returns a set of attributes for the item 1841 * with the given primary key. If there is no matching item, <code>GetItem</code> 1842 * does not return any data and there will be no <code>Item</code> element in the 1843 * response.</p> <p> <code>GetItem</code> provides an eventually consistent read by 1844 * default. If your application requires a strongly consistent read, set 1845 * <code>ConsistentRead</code> to <code>true</code>. Although a strongly consistent 1846 * read might take more time than an eventually consistent read, it always returns 1847 * the last updated value.</p><p><h3>See Also:</h3> <a 1848 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/GetItem">AWS 1849 * API Reference</a></p> 1850 * 1851 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1852 */ 1853 virtual void GetItemAsync(const Model::GetItemRequest& request, const GetItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1854 1855 /** 1856 * <p>List backups associated with an AWS account. To list backups for a given 1857 * table, specify <code>TableName</code>. <code>ListBackups</code> returns a 1858 * paginated list of results with at most 1 MB worth of items in a page. You can 1859 * also specify a maximum number of entries to be returned in a page. </p> <p>In 1860 * the request, start time is inclusive, but end time is exclusive. Note that these 1861 * boundaries are for the time at which the original backup was requested.</p> 1862 * <p>You can call <code>ListBackups</code> a maximum of five times per 1863 * second.</p><p><h3>See Also:</h3> <a 1864 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ListBackups">AWS 1865 * API Reference</a></p> 1866 */ 1867 virtual Model::ListBackupsOutcome ListBackups(const Model::ListBackupsRequest& request) const; 1868 1869 /** 1870 * <p>List backups associated with an AWS account. To list backups for a given 1871 * table, specify <code>TableName</code>. <code>ListBackups</code> returns a 1872 * paginated list of results with at most 1 MB worth of items in a page. You can 1873 * also specify a maximum number of entries to be returned in a page. </p> <p>In 1874 * the request, start time is inclusive, but end time is exclusive. Note that these 1875 * boundaries are for the time at which the original backup was requested.</p> 1876 * <p>You can call <code>ListBackups</code> a maximum of five times per 1877 * second.</p><p><h3>See Also:</h3> <a 1878 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ListBackups">AWS 1879 * API Reference</a></p> 1880 * 1881 * returns a future to the operation so that it can be executed in parallel to other requests. 1882 */ 1883 virtual Model::ListBackupsOutcomeCallable ListBackupsCallable(const Model::ListBackupsRequest& request) const; 1884 1885 /** 1886 * <p>List backups associated with an AWS account. To list backups for a given 1887 * table, specify <code>TableName</code>. <code>ListBackups</code> returns a 1888 * paginated list of results with at most 1 MB worth of items in a page. You can 1889 * also specify a maximum number of entries to be returned in a page. </p> <p>In 1890 * the request, start time is inclusive, but end time is exclusive. Note that these 1891 * boundaries are for the time at which the original backup was requested.</p> 1892 * <p>You can call <code>ListBackups</code> a maximum of five times per 1893 * second.</p><p><h3>See Also:</h3> <a 1894 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ListBackups">AWS 1895 * API Reference</a></p> 1896 * 1897 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1898 */ 1899 virtual void ListBackupsAsync(const Model::ListBackupsRequest& request, const ListBackupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1900 1901 /** 1902 * <p>Returns a list of ContributorInsightsSummary for a table and all its global 1903 * secondary indexes.</p><p><h3>See Also:</h3> <a 1904 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ListContributorInsights">AWS 1905 * API Reference</a></p> 1906 */ 1907 virtual Model::ListContributorInsightsOutcome ListContributorInsights(const Model::ListContributorInsightsRequest& request) const; 1908 1909 /** 1910 * <p>Returns a list of ContributorInsightsSummary for a table and all its global 1911 * secondary indexes.</p><p><h3>See Also:</h3> <a 1912 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ListContributorInsights">AWS 1913 * API Reference</a></p> 1914 * 1915 * returns a future to the operation so that it can be executed in parallel to other requests. 1916 */ 1917 virtual Model::ListContributorInsightsOutcomeCallable ListContributorInsightsCallable(const Model::ListContributorInsightsRequest& request) const; 1918 1919 /** 1920 * <p>Returns a list of ContributorInsightsSummary for a table and all its global 1921 * secondary indexes.</p><p><h3>See Also:</h3> <a 1922 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ListContributorInsights">AWS 1923 * API Reference</a></p> 1924 * 1925 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1926 */ 1927 virtual void ListContributorInsightsAsync(const Model::ListContributorInsightsRequest& request, const ListContributorInsightsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1928 1929 /** 1930 * <p>Lists completed exports within the past 90 days.</p><p><h3>See Also:</h3> 1931 * <a 1932 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ListExports">AWS 1933 * API Reference</a></p> 1934 */ 1935 virtual Model::ListExportsOutcome ListExports(const Model::ListExportsRequest& request) const; 1936 1937 /** 1938 * <p>Lists completed exports within the past 90 days.</p><p><h3>See Also:</h3> 1939 * <a 1940 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ListExports">AWS 1941 * API Reference</a></p> 1942 * 1943 * returns a future to the operation so that it can be executed in parallel to other requests. 1944 */ 1945 virtual Model::ListExportsOutcomeCallable ListExportsCallable(const Model::ListExportsRequest& request) const; 1946 1947 /** 1948 * <p>Lists completed exports within the past 90 days.</p><p><h3>See Also:</h3> 1949 * <a 1950 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ListExports">AWS 1951 * API Reference</a></p> 1952 * 1953 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1954 */ 1955 virtual void ListExportsAsync(const Model::ListExportsRequest& request, const ListExportsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1956 1957 /** 1958 * <p>Lists all global tables that have a replica in the specified Region.</p> 1959 * <p>This operation only applies to <a 1960 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html">Version 1961 * 2017.11.29</a> of global tables.</p> <p><h3>See Also:</h3> <a 1962 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ListGlobalTables">AWS 1963 * API Reference</a></p> 1964 */ 1965 virtual Model::ListGlobalTablesOutcome ListGlobalTables(const Model::ListGlobalTablesRequest& request) const; 1966 1967 /** 1968 * <p>Lists all global tables that have a replica in the specified Region.</p> 1969 * <p>This operation only applies to <a 1970 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html">Version 1971 * 2017.11.29</a> of global tables.</p> <p><h3>See Also:</h3> <a 1972 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ListGlobalTables">AWS 1973 * API Reference</a></p> 1974 * 1975 * returns a future to the operation so that it can be executed in parallel to other requests. 1976 */ 1977 virtual Model::ListGlobalTablesOutcomeCallable ListGlobalTablesCallable(const Model::ListGlobalTablesRequest& request) const; 1978 1979 /** 1980 * <p>Lists all global tables that have a replica in the specified Region.</p> 1981 * <p>This operation only applies to <a 1982 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html">Version 1983 * 2017.11.29</a> of global tables.</p> <p><h3>See Also:</h3> <a 1984 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ListGlobalTables">AWS 1985 * API Reference</a></p> 1986 * 1987 * Queues the request into a thread executor and triggers associated callback when operation has finished. 1988 */ 1989 virtual void ListGlobalTablesAsync(const Model::ListGlobalTablesRequest& request, const ListGlobalTablesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 1990 1991 /** 1992 * <p>Returns an array of table names associated with the current account and 1993 * endpoint. The output from <code>ListTables</code> is paginated, with each page 1994 * returning a maximum of 100 table names.</p><p><h3>See Also:</h3> <a 1995 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ListTables">AWS 1996 * API Reference</a></p> 1997 */ 1998 virtual Model::ListTablesOutcome ListTables(const Model::ListTablesRequest& request) const; 1999 2000 /** 2001 * <p>Returns an array of table names associated with the current account and 2002 * endpoint. The output from <code>ListTables</code> is paginated, with each page 2003 * returning a maximum of 100 table names.</p><p><h3>See Also:</h3> <a 2004 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ListTables">AWS 2005 * API Reference</a></p> 2006 * 2007 * returns a future to the operation so that it can be executed in parallel to other requests. 2008 */ 2009 virtual Model::ListTablesOutcomeCallable ListTablesCallable(const Model::ListTablesRequest& request) const; 2010 2011 /** 2012 * <p>Returns an array of table names associated with the current account and 2013 * endpoint. The output from <code>ListTables</code> is paginated, with each page 2014 * returning a maximum of 100 table names.</p><p><h3>See Also:</h3> <a 2015 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ListTables">AWS 2016 * API Reference</a></p> 2017 * 2018 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2019 */ 2020 virtual void ListTablesAsync(const Model::ListTablesRequest& request, const ListTablesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2021 2022 /** 2023 * <p>List all tags on an Amazon DynamoDB resource. You can call ListTagsOfResource 2024 * up to 10 times per second, per account.</p> <p>For an overview on tagging 2025 * DynamoDB resources, see <a 2026 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html">Tagging 2027 * for DynamoDB</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><p><h3>See 2028 * Also:</h3> <a 2029 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ListTagsOfResource">AWS 2030 * API Reference</a></p> 2031 */ 2032 virtual Model::ListTagsOfResourceOutcome ListTagsOfResource(const Model::ListTagsOfResourceRequest& request) const; 2033 2034 /** 2035 * <p>List all tags on an Amazon DynamoDB resource. You can call ListTagsOfResource 2036 * up to 10 times per second, per account.</p> <p>For an overview on tagging 2037 * DynamoDB resources, see <a 2038 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html">Tagging 2039 * for DynamoDB</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><p><h3>See 2040 * Also:</h3> <a 2041 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ListTagsOfResource">AWS 2042 * API Reference</a></p> 2043 * 2044 * returns a future to the operation so that it can be executed in parallel to other requests. 2045 */ 2046 virtual Model::ListTagsOfResourceOutcomeCallable ListTagsOfResourceCallable(const Model::ListTagsOfResourceRequest& request) const; 2047 2048 /** 2049 * <p>List all tags on an Amazon DynamoDB resource. You can call ListTagsOfResource 2050 * up to 10 times per second, per account.</p> <p>For an overview on tagging 2051 * DynamoDB resources, see <a 2052 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html">Tagging 2053 * for DynamoDB</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><p><h3>See 2054 * Also:</h3> <a 2055 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/ListTagsOfResource">AWS 2056 * API Reference</a></p> 2057 * 2058 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2059 */ 2060 virtual void ListTagsOfResourceAsync(const Model::ListTagsOfResourceRequest& request, const ListTagsOfResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2061 2062 /** 2063 * <p>Creates a new item, or replaces an old item with a new item. If an item that 2064 * has the same primary key as the new item already exists in the specified table, 2065 * the new item completely replaces the existing item. You can perform a 2066 * conditional put operation (add a new item if one with the specified primary key 2067 * doesn't exist), or replace an existing item if it has certain attribute values. 2068 * You can return the item's attribute values in the same operation, using the 2069 * <code>ReturnValues</code> parameter.</p> <p>This topic provides 2070 * general information about the <code>PutItem</code> API.</p> <p>For information 2071 * on how to call the <code>PutItem</code> API using the AWS SDK in specific 2072 * languages, see the following:</p> <ul> <li> <p> <a 2073 * href="http://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/PutItem"> 2074 * PutItem in the AWS Command Line Interface</a> </p> </li> <li> <p> <a 2075 * href="http://docs.aws.amazon.com/goto/DotNetSDKV3/dynamodb-2012-08-10/PutItem"> 2076 * PutItem in the AWS SDK for .NET</a> </p> </li> <li> <p> <a 2077 * href="http://docs.aws.amazon.com/goto/SdkForCpp/dynamodb-2012-08-10/PutItem"> 2078 * PutItem in the AWS SDK for C++</a> </p> </li> <li> <p> <a 2079 * href="http://docs.aws.amazon.com/goto/SdkForGoV1/dynamodb-2012-08-10/PutItem"> 2080 * PutItem in the AWS SDK for Go</a> </p> </li> <li> <p> <a 2081 * href="http://docs.aws.amazon.com/goto/SdkForJava/dynamodb-2012-08-10/PutItem"> 2082 * PutItem in the AWS SDK for Java</a> </p> </li> <li> <p> <a 2083 * href="http://docs.aws.amazon.com/goto/AWSJavaScriptSDK/dynamodb-2012-08-10/PutItem"> 2084 * PutItem in the AWS SDK for JavaScript</a> </p> </li> <li> <p> <a 2085 * href="http://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/PutItem"> 2086 * PutItem in the AWS SDK for PHP V3</a> </p> </li> <li> <p> <a 2087 * href="http://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/PutItem"> 2088 * PutItem in the AWS SDK for Python</a> </p> </li> <li> <p> <a 2089 * href="http://docs.aws.amazon.com/goto/SdkForRubyV2/dynamodb-2012-08-10/PutItem"> 2090 * PutItem in the AWS SDK for Ruby V2</a> </p> </li> </ul> <p>When you 2091 * add an item, the primary key attributes are the only required attributes. 2092 * Attribute values cannot be null.</p> <p>Empty String and Binary attribute values 2093 * are allowed. Attribute values of type String and Binary must have a length 2094 * greater than zero if the attribute is used as a key attribute for a table or 2095 * index. Set type attributes cannot be empty. </p> <p>Invalid Requests with empty 2096 * values will be rejected with a <code>ValidationException</code> exception.</p> 2097 * <p>To prevent a new item from replacing an existing item, use a 2098 * conditional expression that contains the <code>attribute_not_exists</code> 2099 * function with the name of the attribute being used as the partition key for the 2100 * table. Since every record must contain that attribute, the 2101 * <code>attribute_not_exists</code> function will only succeed if no matching item 2102 * exists.</p> <p>For more information about <code>PutItem</code>, see <a 2103 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html">Working 2104 * with Items</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><p><h3>See 2105 * Also:</h3> <a 2106 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/PutItem">AWS 2107 * API Reference</a></p> 2108 */ 2109 virtual Model::PutItemOutcome PutItem(const Model::PutItemRequest& request) const; 2110 2111 /** 2112 * <p>Creates a new item, or replaces an old item with a new item. If an item that 2113 * has the same primary key as the new item already exists in the specified table, 2114 * the new item completely replaces the existing item. You can perform a 2115 * conditional put operation (add a new item if one with the specified primary key 2116 * doesn't exist), or replace an existing item if it has certain attribute values. 2117 * You can return the item's attribute values in the same operation, using the 2118 * <code>ReturnValues</code> parameter.</p> <p>This topic provides 2119 * general information about the <code>PutItem</code> API.</p> <p>For information 2120 * on how to call the <code>PutItem</code> API using the AWS SDK in specific 2121 * languages, see the following:</p> <ul> <li> <p> <a 2122 * href="http://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/PutItem"> 2123 * PutItem in the AWS Command Line Interface</a> </p> </li> <li> <p> <a 2124 * href="http://docs.aws.amazon.com/goto/DotNetSDKV3/dynamodb-2012-08-10/PutItem"> 2125 * PutItem in the AWS SDK for .NET</a> </p> </li> <li> <p> <a 2126 * href="http://docs.aws.amazon.com/goto/SdkForCpp/dynamodb-2012-08-10/PutItem"> 2127 * PutItem in the AWS SDK for C++</a> </p> </li> <li> <p> <a 2128 * href="http://docs.aws.amazon.com/goto/SdkForGoV1/dynamodb-2012-08-10/PutItem"> 2129 * PutItem in the AWS SDK for Go</a> </p> </li> <li> <p> <a 2130 * href="http://docs.aws.amazon.com/goto/SdkForJava/dynamodb-2012-08-10/PutItem"> 2131 * PutItem in the AWS SDK for Java</a> </p> </li> <li> <p> <a 2132 * href="http://docs.aws.amazon.com/goto/AWSJavaScriptSDK/dynamodb-2012-08-10/PutItem"> 2133 * PutItem in the AWS SDK for JavaScript</a> </p> </li> <li> <p> <a 2134 * href="http://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/PutItem"> 2135 * PutItem in the AWS SDK for PHP V3</a> </p> </li> <li> <p> <a 2136 * href="http://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/PutItem"> 2137 * PutItem in the AWS SDK for Python</a> </p> </li> <li> <p> <a 2138 * href="http://docs.aws.amazon.com/goto/SdkForRubyV2/dynamodb-2012-08-10/PutItem"> 2139 * PutItem in the AWS SDK for Ruby V2</a> </p> </li> </ul> <p>When you 2140 * add an item, the primary key attributes are the only required attributes. 2141 * Attribute values cannot be null.</p> <p>Empty String and Binary attribute values 2142 * are allowed. Attribute values of type String and Binary must have a length 2143 * greater than zero if the attribute is used as a key attribute for a table or 2144 * index. Set type attributes cannot be empty. </p> <p>Invalid Requests with empty 2145 * values will be rejected with a <code>ValidationException</code> exception.</p> 2146 * <p>To prevent a new item from replacing an existing item, use a 2147 * conditional expression that contains the <code>attribute_not_exists</code> 2148 * function with the name of the attribute being used as the partition key for the 2149 * table. Since every record must contain that attribute, the 2150 * <code>attribute_not_exists</code> function will only succeed if no matching item 2151 * exists.</p> <p>For more information about <code>PutItem</code>, see <a 2152 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html">Working 2153 * with Items</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><p><h3>See 2154 * Also:</h3> <a 2155 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/PutItem">AWS 2156 * API Reference</a></p> 2157 * 2158 * returns a future to the operation so that it can be executed in parallel to other requests. 2159 */ 2160 virtual Model::PutItemOutcomeCallable PutItemCallable(const Model::PutItemRequest& request) const; 2161 2162 /** 2163 * <p>Creates a new item, or replaces an old item with a new item. If an item that 2164 * has the same primary key as the new item already exists in the specified table, 2165 * the new item completely replaces the existing item. You can perform a 2166 * conditional put operation (add a new item if one with the specified primary key 2167 * doesn't exist), or replace an existing item if it has certain attribute values. 2168 * You can return the item's attribute values in the same operation, using the 2169 * <code>ReturnValues</code> parameter.</p> <p>This topic provides 2170 * general information about the <code>PutItem</code> API.</p> <p>For information 2171 * on how to call the <code>PutItem</code> API using the AWS SDK in specific 2172 * languages, see the following:</p> <ul> <li> <p> <a 2173 * href="http://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/PutItem"> 2174 * PutItem in the AWS Command Line Interface</a> </p> </li> <li> <p> <a 2175 * href="http://docs.aws.amazon.com/goto/DotNetSDKV3/dynamodb-2012-08-10/PutItem"> 2176 * PutItem in the AWS SDK for .NET</a> </p> </li> <li> <p> <a 2177 * href="http://docs.aws.amazon.com/goto/SdkForCpp/dynamodb-2012-08-10/PutItem"> 2178 * PutItem in the AWS SDK for C++</a> </p> </li> <li> <p> <a 2179 * href="http://docs.aws.amazon.com/goto/SdkForGoV1/dynamodb-2012-08-10/PutItem"> 2180 * PutItem in the AWS SDK for Go</a> </p> </li> <li> <p> <a 2181 * href="http://docs.aws.amazon.com/goto/SdkForJava/dynamodb-2012-08-10/PutItem"> 2182 * PutItem in the AWS SDK for Java</a> </p> </li> <li> <p> <a 2183 * href="http://docs.aws.amazon.com/goto/AWSJavaScriptSDK/dynamodb-2012-08-10/PutItem"> 2184 * PutItem in the AWS SDK for JavaScript</a> </p> </li> <li> <p> <a 2185 * href="http://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/PutItem"> 2186 * PutItem in the AWS SDK for PHP V3</a> </p> </li> <li> <p> <a 2187 * href="http://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/PutItem"> 2188 * PutItem in the AWS SDK for Python</a> </p> </li> <li> <p> <a 2189 * href="http://docs.aws.amazon.com/goto/SdkForRubyV2/dynamodb-2012-08-10/PutItem"> 2190 * PutItem in the AWS SDK for Ruby V2</a> </p> </li> </ul> <p>When you 2191 * add an item, the primary key attributes are the only required attributes. 2192 * Attribute values cannot be null.</p> <p>Empty String and Binary attribute values 2193 * are allowed. Attribute values of type String and Binary must have a length 2194 * greater than zero if the attribute is used as a key attribute for a table or 2195 * index. Set type attributes cannot be empty. </p> <p>Invalid Requests with empty 2196 * values will be rejected with a <code>ValidationException</code> exception.</p> 2197 * <p>To prevent a new item from replacing an existing item, use a 2198 * conditional expression that contains the <code>attribute_not_exists</code> 2199 * function with the name of the attribute being used as the partition key for the 2200 * table. Since every record must contain that attribute, the 2201 * <code>attribute_not_exists</code> function will only succeed if no matching item 2202 * exists.</p> <p>For more information about <code>PutItem</code>, see <a 2203 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html">Working 2204 * with Items</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><p><h3>See 2205 * Also:</h3> <a 2206 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/PutItem">AWS 2207 * API Reference</a></p> 2208 * 2209 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2210 */ 2211 virtual void PutItemAsync(const Model::PutItemRequest& request, const PutItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2212 2213 /** 2214 * <p>The <code>Query</code> operation finds items based on primary key values. You 2215 * can query any table or secondary index that has a composite primary key (a 2216 * partition key and a sort key). </p> <p>Use the 2217 * <code>KeyConditionExpression</code> parameter to provide a specific value for 2218 * the partition key. The <code>Query</code> operation will return all of the items 2219 * from the table or index with that partition key value. You can optionally narrow 2220 * the scope of the <code>Query</code> operation by specifying a sort key value and 2221 * a comparison operator in <code>KeyConditionExpression</code>. To further refine 2222 * the <code>Query</code> results, you can optionally provide a 2223 * <code>FilterExpression</code>. A <code>FilterExpression</code> determines which 2224 * items within the results should be returned to you. All of the other results are 2225 * discarded. </p> <p> A <code>Query</code> operation always returns a result set. 2226 * If no matching items are found, the result set will be empty. Queries that do 2227 * not return results consume the minimum number of read capacity units for that 2228 * type of read operation. </p> <p> DynamoDB calculates the number of read 2229 * capacity units consumed based on item size, not on the amount of data that is 2230 * returned to an application. The number of capacity units consumed will be the 2231 * same whether you request all of the attributes (the default behavior) or just 2232 * some of them (using a projection expression). The number will also be the same 2233 * whether or not you use a <code>FilterExpression</code>. </p> <p> 2234 * <code>Query</code> results are always sorted by the sort key value. If the data 2235 * type of the sort key is Number, the results are returned in numeric order; 2236 * otherwise, the results are returned in order of UTF-8 bytes. By default, the 2237 * sort order is ascending. To reverse the order, set the 2238 * <code>ScanIndexForward</code> parameter to false. </p> <p> A single 2239 * <code>Query</code> operation will read up to the maximum number of items set (if 2240 * using the <code>Limit</code> parameter) or a maximum of 1 MB of data and then 2241 * apply any filtering to the results using <code>FilterExpression</code>. If 2242 * <code>LastEvaluatedKey</code> is present in the response, you will need to 2243 * paginate the result set. For more information, see <a 2244 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html#Query.Pagination">Paginating 2245 * the Results</a> in the <i>Amazon DynamoDB Developer Guide</i>. </p> <p> 2246 * <code>FilterExpression</code> is applied after a <code>Query</code> finishes, 2247 * but before the results are returned. A <code>FilterExpression</code> cannot 2248 * contain partition key or sort key attributes. You need to specify those 2249 * attributes in the <code>KeyConditionExpression</code>. </p> <p> A 2250 * <code>Query</code> operation can return an empty result set and a 2251 * <code>LastEvaluatedKey</code> if all the items read for the page of results are 2252 * filtered out. </p> <p>You can query a table, a local secondary index, or 2253 * a global secondary index. For a query on a table or on a local secondary index, 2254 * you can set the <code>ConsistentRead</code> parameter to <code>true</code> and 2255 * obtain a strongly consistent result. Global secondary indexes support eventually 2256 * consistent reads only, so do not specify <code>ConsistentRead</code> when 2257 * querying a global secondary index.</p><p><h3>See Also:</h3> <a 2258 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/Query">AWS API 2259 * Reference</a></p> 2260 */ 2261 virtual Model::QueryOutcome Query(const Model::QueryRequest& request) const; 2262 2263 /** 2264 * <p>The <code>Query</code> operation finds items based on primary key values. You 2265 * can query any table or secondary index that has a composite primary key (a 2266 * partition key and a sort key). </p> <p>Use the 2267 * <code>KeyConditionExpression</code> parameter to provide a specific value for 2268 * the partition key. The <code>Query</code> operation will return all of the items 2269 * from the table or index with that partition key value. You can optionally narrow 2270 * the scope of the <code>Query</code> operation by specifying a sort key value and 2271 * a comparison operator in <code>KeyConditionExpression</code>. To further refine 2272 * the <code>Query</code> results, you can optionally provide a 2273 * <code>FilterExpression</code>. A <code>FilterExpression</code> determines which 2274 * items within the results should be returned to you. All of the other results are 2275 * discarded. </p> <p> A <code>Query</code> operation always returns a result set. 2276 * If no matching items are found, the result set will be empty. Queries that do 2277 * not return results consume the minimum number of read capacity units for that 2278 * type of read operation. </p> <p> DynamoDB calculates the number of read 2279 * capacity units consumed based on item size, not on the amount of data that is 2280 * returned to an application. The number of capacity units consumed will be the 2281 * same whether you request all of the attributes (the default behavior) or just 2282 * some of them (using a projection expression). The number will also be the same 2283 * whether or not you use a <code>FilterExpression</code>. </p> <p> 2284 * <code>Query</code> results are always sorted by the sort key value. If the data 2285 * type of the sort key is Number, the results are returned in numeric order; 2286 * otherwise, the results are returned in order of UTF-8 bytes. By default, the 2287 * sort order is ascending. To reverse the order, set the 2288 * <code>ScanIndexForward</code> parameter to false. </p> <p> A single 2289 * <code>Query</code> operation will read up to the maximum number of items set (if 2290 * using the <code>Limit</code> parameter) or a maximum of 1 MB of data and then 2291 * apply any filtering to the results using <code>FilterExpression</code>. If 2292 * <code>LastEvaluatedKey</code> is present in the response, you will need to 2293 * paginate the result set. For more information, see <a 2294 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html#Query.Pagination">Paginating 2295 * the Results</a> in the <i>Amazon DynamoDB Developer Guide</i>. </p> <p> 2296 * <code>FilterExpression</code> is applied after a <code>Query</code> finishes, 2297 * but before the results are returned. A <code>FilterExpression</code> cannot 2298 * contain partition key or sort key attributes. You need to specify those 2299 * attributes in the <code>KeyConditionExpression</code>. </p> <p> A 2300 * <code>Query</code> operation can return an empty result set and a 2301 * <code>LastEvaluatedKey</code> if all the items read for the page of results are 2302 * filtered out. </p> <p>You can query a table, a local secondary index, or 2303 * a global secondary index. For a query on a table or on a local secondary index, 2304 * you can set the <code>ConsistentRead</code> parameter to <code>true</code> and 2305 * obtain a strongly consistent result. Global secondary indexes support eventually 2306 * consistent reads only, so do not specify <code>ConsistentRead</code> when 2307 * querying a global secondary index.</p><p><h3>See Also:</h3> <a 2308 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/Query">AWS API 2309 * Reference</a></p> 2310 * 2311 * returns a future to the operation so that it can be executed in parallel to other requests. 2312 */ 2313 virtual Model::QueryOutcomeCallable QueryCallable(const Model::QueryRequest& request) const; 2314 2315 /** 2316 * <p>The <code>Query</code> operation finds items based on primary key values. You 2317 * can query any table or secondary index that has a composite primary key (a 2318 * partition key and a sort key). </p> <p>Use the 2319 * <code>KeyConditionExpression</code> parameter to provide a specific value for 2320 * the partition key. The <code>Query</code> operation will return all of the items 2321 * from the table or index with that partition key value. You can optionally narrow 2322 * the scope of the <code>Query</code> operation by specifying a sort key value and 2323 * a comparison operator in <code>KeyConditionExpression</code>. To further refine 2324 * the <code>Query</code> results, you can optionally provide a 2325 * <code>FilterExpression</code>. A <code>FilterExpression</code> determines which 2326 * items within the results should be returned to you. All of the other results are 2327 * discarded. </p> <p> A <code>Query</code> operation always returns a result set. 2328 * If no matching items are found, the result set will be empty. Queries that do 2329 * not return results consume the minimum number of read capacity units for that 2330 * type of read operation. </p> <p> DynamoDB calculates the number of read 2331 * capacity units consumed based on item size, not on the amount of data that is 2332 * returned to an application. The number of capacity units consumed will be the 2333 * same whether you request all of the attributes (the default behavior) or just 2334 * some of them (using a projection expression). The number will also be the same 2335 * whether or not you use a <code>FilterExpression</code>. </p> <p> 2336 * <code>Query</code> results are always sorted by the sort key value. If the data 2337 * type of the sort key is Number, the results are returned in numeric order; 2338 * otherwise, the results are returned in order of UTF-8 bytes. By default, the 2339 * sort order is ascending. To reverse the order, set the 2340 * <code>ScanIndexForward</code> parameter to false. </p> <p> A single 2341 * <code>Query</code> operation will read up to the maximum number of items set (if 2342 * using the <code>Limit</code> parameter) or a maximum of 1 MB of data and then 2343 * apply any filtering to the results using <code>FilterExpression</code>. If 2344 * <code>LastEvaluatedKey</code> is present in the response, you will need to 2345 * paginate the result set. For more information, see <a 2346 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html#Query.Pagination">Paginating 2347 * the Results</a> in the <i>Amazon DynamoDB Developer Guide</i>. </p> <p> 2348 * <code>FilterExpression</code> is applied after a <code>Query</code> finishes, 2349 * but before the results are returned. A <code>FilterExpression</code> cannot 2350 * contain partition key or sort key attributes. You need to specify those 2351 * attributes in the <code>KeyConditionExpression</code>. </p> <p> A 2352 * <code>Query</code> operation can return an empty result set and a 2353 * <code>LastEvaluatedKey</code> if all the items read for the page of results are 2354 * filtered out. </p> <p>You can query a table, a local secondary index, or 2355 * a global secondary index. For a query on a table or on a local secondary index, 2356 * you can set the <code>ConsistentRead</code> parameter to <code>true</code> and 2357 * obtain a strongly consistent result. Global secondary indexes support eventually 2358 * consistent reads only, so do not specify <code>ConsistentRead</code> when 2359 * querying a global secondary index.</p><p><h3>See Also:</h3> <a 2360 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/Query">AWS API 2361 * Reference</a></p> 2362 * 2363 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2364 */ 2365 virtual void QueryAsync(const Model::QueryRequest& request, const QueryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2366 2367 /** 2368 * <p>Creates a new table from an existing backup. Any number of users can execute 2369 * up to 4 concurrent restores (any type of restore) in a given account. </p> 2370 * <p>You can call <code>RestoreTableFromBackup</code> at a maximum rate of 10 2371 * times per second.</p> <p>You must manually set up the following on the restored 2372 * table:</p> <ul> <li> <p>Auto scaling policies</p> </li> <li> <p>IAM policies</p> 2373 * </li> <li> <p>Amazon CloudWatch metrics and alarms</p> </li> <li> <p>Tags</p> 2374 * </li> <li> <p>Stream settings</p> </li> <li> <p>Time to Live (TTL) settings</p> 2375 * </li> </ul><p><h3>See Also:</h3> <a 2376 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/RestoreTableFromBackup">AWS 2377 * API Reference</a></p> 2378 */ 2379 virtual Model::RestoreTableFromBackupOutcome RestoreTableFromBackup(const Model::RestoreTableFromBackupRequest& request) const; 2380 2381 /** 2382 * <p>Creates a new table from an existing backup. Any number of users can execute 2383 * up to 4 concurrent restores (any type of restore) in a given account. </p> 2384 * <p>You can call <code>RestoreTableFromBackup</code> at a maximum rate of 10 2385 * times per second.</p> <p>You must manually set up the following on the restored 2386 * table:</p> <ul> <li> <p>Auto scaling policies</p> </li> <li> <p>IAM policies</p> 2387 * </li> <li> <p>Amazon CloudWatch metrics and alarms</p> </li> <li> <p>Tags</p> 2388 * </li> <li> <p>Stream settings</p> </li> <li> <p>Time to Live (TTL) settings</p> 2389 * </li> </ul><p><h3>See Also:</h3> <a 2390 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/RestoreTableFromBackup">AWS 2391 * API Reference</a></p> 2392 * 2393 * returns a future to the operation so that it can be executed in parallel to other requests. 2394 */ 2395 virtual Model::RestoreTableFromBackupOutcomeCallable RestoreTableFromBackupCallable(const Model::RestoreTableFromBackupRequest& request) const; 2396 2397 /** 2398 * <p>Creates a new table from an existing backup. Any number of users can execute 2399 * up to 4 concurrent restores (any type of restore) in a given account. </p> 2400 * <p>You can call <code>RestoreTableFromBackup</code> at a maximum rate of 10 2401 * times per second.</p> <p>You must manually set up the following on the restored 2402 * table:</p> <ul> <li> <p>Auto scaling policies</p> </li> <li> <p>IAM policies</p> 2403 * </li> <li> <p>Amazon CloudWatch metrics and alarms</p> </li> <li> <p>Tags</p> 2404 * </li> <li> <p>Stream settings</p> </li> <li> <p>Time to Live (TTL) settings</p> 2405 * </li> </ul><p><h3>See Also:</h3> <a 2406 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/RestoreTableFromBackup">AWS 2407 * API Reference</a></p> 2408 * 2409 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2410 */ 2411 virtual void RestoreTableFromBackupAsync(const Model::RestoreTableFromBackupRequest& request, const RestoreTableFromBackupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2412 2413 /** 2414 * <p>Restores the specified table to the specified point in time within 2415 * <code>EarliestRestorableDateTime</code> and 2416 * <code>LatestRestorableDateTime</code>. You can restore your table to any point 2417 * in time during the last 35 days. Any number of users can execute up to 4 2418 * concurrent restores (any type of restore) in a given account. </p> <p> When you 2419 * restore using point in time recovery, DynamoDB restores your table data to the 2420 * state based on the selected date and time (day:hour:minute:second) to a new 2421 * table. </p> <p> Along with data, the following are also included on the new 2422 * restored table using point in time recovery: </p> <ul> <li> <p>Global secondary 2423 * indexes (GSIs)</p> </li> <li> <p>Local secondary indexes (LSIs)</p> </li> <li> 2424 * <p>Provisioned read and write capacity</p> </li> <li> <p>Encryption settings</p> 2425 * <p> All these settings come from the current settings of the source 2426 * table at the time of restore. </p> </li> </ul> <p>You must manually 2427 * set up the following on the restored table:</p> <ul> <li> <p>Auto scaling 2428 * policies</p> </li> <li> <p>IAM policies</p> </li> <li> <p>Amazon CloudWatch 2429 * metrics and alarms</p> </li> <li> <p>Tags</p> </li> <li> <p>Stream settings</p> 2430 * </li> <li> <p>Time to Live (TTL) settings</p> </li> <li> <p>Point in time 2431 * recovery settings</p> </li> </ul><p><h3>See Also:</h3> <a 2432 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/RestoreTableToPointInTime">AWS 2433 * API Reference</a></p> 2434 */ 2435 virtual Model::RestoreTableToPointInTimeOutcome RestoreTableToPointInTime(const Model::RestoreTableToPointInTimeRequest& request) const; 2436 2437 /** 2438 * <p>Restores the specified table to the specified point in time within 2439 * <code>EarliestRestorableDateTime</code> and 2440 * <code>LatestRestorableDateTime</code>. You can restore your table to any point 2441 * in time during the last 35 days. Any number of users can execute up to 4 2442 * concurrent restores (any type of restore) in a given account. </p> <p> When you 2443 * restore using point in time recovery, DynamoDB restores your table data to the 2444 * state based on the selected date and time (day:hour:minute:second) to a new 2445 * table. </p> <p> Along with data, the following are also included on the new 2446 * restored table using point in time recovery: </p> <ul> <li> <p>Global secondary 2447 * indexes (GSIs)</p> </li> <li> <p>Local secondary indexes (LSIs)</p> </li> <li> 2448 * <p>Provisioned read and write capacity</p> </li> <li> <p>Encryption settings</p> 2449 * <p> All these settings come from the current settings of the source 2450 * table at the time of restore. </p> </li> </ul> <p>You must manually 2451 * set up the following on the restored table:</p> <ul> <li> <p>Auto scaling 2452 * policies</p> </li> <li> <p>IAM policies</p> </li> <li> <p>Amazon CloudWatch 2453 * metrics and alarms</p> </li> <li> <p>Tags</p> </li> <li> <p>Stream settings</p> 2454 * </li> <li> <p>Time to Live (TTL) settings</p> </li> <li> <p>Point in time 2455 * recovery settings</p> </li> </ul><p><h3>See Also:</h3> <a 2456 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/RestoreTableToPointInTime">AWS 2457 * API Reference</a></p> 2458 * 2459 * returns a future to the operation so that it can be executed in parallel to other requests. 2460 */ 2461 virtual Model::RestoreTableToPointInTimeOutcomeCallable RestoreTableToPointInTimeCallable(const Model::RestoreTableToPointInTimeRequest& request) const; 2462 2463 /** 2464 * <p>Restores the specified table to the specified point in time within 2465 * <code>EarliestRestorableDateTime</code> and 2466 * <code>LatestRestorableDateTime</code>. You can restore your table to any point 2467 * in time during the last 35 days. Any number of users can execute up to 4 2468 * concurrent restores (any type of restore) in a given account. </p> <p> When you 2469 * restore using point in time recovery, DynamoDB restores your table data to the 2470 * state based on the selected date and time (day:hour:minute:second) to a new 2471 * table. </p> <p> Along with data, the following are also included on the new 2472 * restored table using point in time recovery: </p> <ul> <li> <p>Global secondary 2473 * indexes (GSIs)</p> </li> <li> <p>Local secondary indexes (LSIs)</p> </li> <li> 2474 * <p>Provisioned read and write capacity</p> </li> <li> <p>Encryption settings</p> 2475 * <p> All these settings come from the current settings of the source 2476 * table at the time of restore. </p> </li> </ul> <p>You must manually 2477 * set up the following on the restored table:</p> <ul> <li> <p>Auto scaling 2478 * policies</p> </li> <li> <p>IAM policies</p> </li> <li> <p>Amazon CloudWatch 2479 * metrics and alarms</p> </li> <li> <p>Tags</p> </li> <li> <p>Stream settings</p> 2480 * </li> <li> <p>Time to Live (TTL) settings</p> </li> <li> <p>Point in time 2481 * recovery settings</p> </li> </ul><p><h3>See Also:</h3> <a 2482 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/RestoreTableToPointInTime">AWS 2483 * API Reference</a></p> 2484 * 2485 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2486 */ 2487 virtual void RestoreTableToPointInTimeAsync(const Model::RestoreTableToPointInTimeRequest& request, const RestoreTableToPointInTimeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2488 2489 /** 2490 * <p>The <code>Scan</code> operation returns one or more items and item attributes 2491 * by accessing every item in a table or a secondary index. To have DynamoDB return 2492 * fewer items, you can provide a <code>FilterExpression</code> operation.</p> 2493 * <p>If the total number of scanned items exceeds the maximum dataset size limit 2494 * of 1 MB, the scan stops and results are returned to the user as a 2495 * <code>LastEvaluatedKey</code> value to continue the scan in a subsequent 2496 * operation. The results also include the number of items exceeding the limit. A 2497 * scan can result in no table data meeting the filter criteria. </p> <p>A single 2498 * <code>Scan</code> operation reads up to the maximum number of items set (if 2499 * using the <code>Limit</code> parameter) or a maximum of 1 MB of data and then 2500 * apply any filtering to the results using <code>FilterExpression</code>. If 2501 * <code>LastEvaluatedKey</code> is present in the response, you need to paginate 2502 * the result set. For more information, see <a 2503 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html#Scan.Pagination">Paginating 2504 * the Results</a> in the <i>Amazon DynamoDB Developer Guide</i>. </p> <p> 2505 * <code>Scan</code> operations proceed sequentially; however, for faster 2506 * performance on a large table or secondary index, applications can request a 2507 * parallel <code>Scan</code> operation by providing the <code>Segment</code> and 2508 * <code>TotalSegments</code> parameters. For more information, see <a 2509 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html#Scan.ParallelScan">Parallel 2510 * Scan</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> <p> 2511 * <code>Scan</code> uses eventually consistent reads when accessing the data in a 2512 * table; therefore, the result set might not include the changes to data in the 2513 * table immediately before the operation began. If you need a consistent copy of 2514 * the data, as of the time that the <code>Scan</code> begins, you can set the 2515 * <code>ConsistentRead</code> parameter to <code>true</code>.</p><p><h3>See 2516 * Also:</h3> <a 2517 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/Scan">AWS API 2518 * Reference</a></p> 2519 */ 2520 virtual Model::ScanOutcome Scan(const Model::ScanRequest& request) const; 2521 2522 /** 2523 * <p>The <code>Scan</code> operation returns one or more items and item attributes 2524 * by accessing every item in a table or a secondary index. To have DynamoDB return 2525 * fewer items, you can provide a <code>FilterExpression</code> operation.</p> 2526 * <p>If the total number of scanned items exceeds the maximum dataset size limit 2527 * of 1 MB, the scan stops and results are returned to the user as a 2528 * <code>LastEvaluatedKey</code> value to continue the scan in a subsequent 2529 * operation. The results also include the number of items exceeding the limit. A 2530 * scan can result in no table data meeting the filter criteria. </p> <p>A single 2531 * <code>Scan</code> operation reads up to the maximum number of items set (if 2532 * using the <code>Limit</code> parameter) or a maximum of 1 MB of data and then 2533 * apply any filtering to the results using <code>FilterExpression</code>. If 2534 * <code>LastEvaluatedKey</code> is present in the response, you need to paginate 2535 * the result set. For more information, see <a 2536 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html#Scan.Pagination">Paginating 2537 * the Results</a> in the <i>Amazon DynamoDB Developer Guide</i>. </p> <p> 2538 * <code>Scan</code> operations proceed sequentially; however, for faster 2539 * performance on a large table or secondary index, applications can request a 2540 * parallel <code>Scan</code> operation by providing the <code>Segment</code> and 2541 * <code>TotalSegments</code> parameters. For more information, see <a 2542 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html#Scan.ParallelScan">Parallel 2543 * Scan</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> <p> 2544 * <code>Scan</code> uses eventually consistent reads when accessing the data in a 2545 * table; therefore, the result set might not include the changes to data in the 2546 * table immediately before the operation began. If you need a consistent copy of 2547 * the data, as of the time that the <code>Scan</code> begins, you can set the 2548 * <code>ConsistentRead</code> parameter to <code>true</code>.</p><p><h3>See 2549 * Also:</h3> <a 2550 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/Scan">AWS API 2551 * Reference</a></p> 2552 * 2553 * returns a future to the operation so that it can be executed in parallel to other requests. 2554 */ 2555 virtual Model::ScanOutcomeCallable ScanCallable(const Model::ScanRequest& request) const; 2556 2557 /** 2558 * <p>The <code>Scan</code> operation returns one or more items and item attributes 2559 * by accessing every item in a table or a secondary index. To have DynamoDB return 2560 * fewer items, you can provide a <code>FilterExpression</code> operation.</p> 2561 * <p>If the total number of scanned items exceeds the maximum dataset size limit 2562 * of 1 MB, the scan stops and results are returned to the user as a 2563 * <code>LastEvaluatedKey</code> value to continue the scan in a subsequent 2564 * operation. The results also include the number of items exceeding the limit. A 2565 * scan can result in no table data meeting the filter criteria. </p> <p>A single 2566 * <code>Scan</code> operation reads up to the maximum number of items set (if 2567 * using the <code>Limit</code> parameter) or a maximum of 1 MB of data and then 2568 * apply any filtering to the results using <code>FilterExpression</code>. If 2569 * <code>LastEvaluatedKey</code> is present in the response, you need to paginate 2570 * the result set. For more information, see <a 2571 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html#Scan.Pagination">Paginating 2572 * the Results</a> in the <i>Amazon DynamoDB Developer Guide</i>. </p> <p> 2573 * <code>Scan</code> operations proceed sequentially; however, for faster 2574 * performance on a large table or secondary index, applications can request a 2575 * parallel <code>Scan</code> operation by providing the <code>Segment</code> and 2576 * <code>TotalSegments</code> parameters. For more information, see <a 2577 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html#Scan.ParallelScan">Parallel 2578 * Scan</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p> <p> 2579 * <code>Scan</code> uses eventually consistent reads when accessing the data in a 2580 * table; therefore, the result set might not include the changes to data in the 2581 * table immediately before the operation began. If you need a consistent copy of 2582 * the data, as of the time that the <code>Scan</code> begins, you can set the 2583 * <code>ConsistentRead</code> parameter to <code>true</code>.</p><p><h3>See 2584 * Also:</h3> <a 2585 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/Scan">AWS API 2586 * Reference</a></p> 2587 * 2588 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2589 */ 2590 virtual void ScanAsync(const Model::ScanRequest& request, const ScanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2591 2592 /** 2593 * <p>Associate a set of tags with an Amazon DynamoDB resource. You can then 2594 * activate these user-defined tags so that they appear on the Billing and Cost 2595 * Management console for cost allocation tracking. You can call TagResource up to 2596 * five times per second, per account. </p> <p>For an overview on tagging DynamoDB 2597 * resources, see <a 2598 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html">Tagging 2599 * for DynamoDB</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><p><h3>See 2600 * Also:</h3> <a 2601 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/TagResource">AWS 2602 * API Reference</a></p> 2603 */ 2604 virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; 2605 2606 /** 2607 * <p>Associate a set of tags with an Amazon DynamoDB resource. You can then 2608 * activate these user-defined tags so that they appear on the Billing and Cost 2609 * Management console for cost allocation tracking. You can call TagResource up to 2610 * five times per second, per account. </p> <p>For an overview on tagging DynamoDB 2611 * resources, see <a 2612 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html">Tagging 2613 * for DynamoDB</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><p><h3>See 2614 * Also:</h3> <a 2615 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/TagResource">AWS 2616 * API Reference</a></p> 2617 * 2618 * returns a future to the operation so that it can be executed in parallel to other requests. 2619 */ 2620 virtual Model::TagResourceOutcomeCallable TagResourceCallable(const Model::TagResourceRequest& request) const; 2621 2622 /** 2623 * <p>Associate a set of tags with an Amazon DynamoDB resource. You can then 2624 * activate these user-defined tags so that they appear on the Billing and Cost 2625 * Management console for cost allocation tracking. You can call TagResource up to 2626 * five times per second, per account. </p> <p>For an overview on tagging DynamoDB 2627 * resources, see <a 2628 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html">Tagging 2629 * for DynamoDB</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><p><h3>See 2630 * Also:</h3> <a 2631 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/TagResource">AWS 2632 * API Reference</a></p> 2633 * 2634 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2635 */ 2636 virtual void TagResourceAsync(const Model::TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2637 2638 /** 2639 * <p> <code>TransactGetItems</code> is a synchronous operation that atomically 2640 * retrieves multiple items from one or more tables (but not from indexes) in a 2641 * single account and Region. A <code>TransactGetItems</code> call can contain up 2642 * to 25 <code>TransactGetItem</code> objects, each of which contains a 2643 * <code>Get</code> structure that specifies an item to retrieve from a table in 2644 * the account and Region. A call to <code>TransactGetItems</code> cannot retrieve 2645 * items from tables in more than one AWS account or Region. The aggregate size of 2646 * the items in the transaction cannot exceed 4 MB.</p> <p>DynamoDB rejects the 2647 * entire <code>TransactGetItems</code> request if any of the following is 2648 * true:</p> <ul> <li> <p>A conflicting operation is in the process of updating an 2649 * item to be read.</p> </li> <li> <p>There is insufficient provisioned capacity 2650 * for the transaction to be completed.</p> </li> <li> <p>There is a user error, 2651 * such as an invalid data format.</p> </li> <li> <p>The aggregate size of the 2652 * items in the transaction cannot exceed 4 MB.</p> </li> </ul><p><h3>See 2653 * Also:</h3> <a 2654 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/TransactGetItems">AWS 2655 * API Reference</a></p> 2656 */ 2657 virtual Model::TransactGetItemsOutcome TransactGetItems(const Model::TransactGetItemsRequest& request) const; 2658 2659 /** 2660 * <p> <code>TransactGetItems</code> is a synchronous operation that atomically 2661 * retrieves multiple items from one or more tables (but not from indexes) in a 2662 * single account and Region. A <code>TransactGetItems</code> call can contain up 2663 * to 25 <code>TransactGetItem</code> objects, each of which contains a 2664 * <code>Get</code> structure that specifies an item to retrieve from a table in 2665 * the account and Region. A call to <code>TransactGetItems</code> cannot retrieve 2666 * items from tables in more than one AWS account or Region. The aggregate size of 2667 * the items in the transaction cannot exceed 4 MB.</p> <p>DynamoDB rejects the 2668 * entire <code>TransactGetItems</code> request if any of the following is 2669 * true:</p> <ul> <li> <p>A conflicting operation is in the process of updating an 2670 * item to be read.</p> </li> <li> <p>There is insufficient provisioned capacity 2671 * for the transaction to be completed.</p> </li> <li> <p>There is a user error, 2672 * such as an invalid data format.</p> </li> <li> <p>The aggregate size of the 2673 * items in the transaction cannot exceed 4 MB.</p> </li> </ul><p><h3>See 2674 * Also:</h3> <a 2675 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/TransactGetItems">AWS 2676 * API Reference</a></p> 2677 * 2678 * returns a future to the operation so that it can be executed in parallel to other requests. 2679 */ 2680 virtual Model::TransactGetItemsOutcomeCallable TransactGetItemsCallable(const Model::TransactGetItemsRequest& request) const; 2681 2682 /** 2683 * <p> <code>TransactGetItems</code> is a synchronous operation that atomically 2684 * retrieves multiple items from one or more tables (but not from indexes) in a 2685 * single account and Region. A <code>TransactGetItems</code> call can contain up 2686 * to 25 <code>TransactGetItem</code> objects, each of which contains a 2687 * <code>Get</code> structure that specifies an item to retrieve from a table in 2688 * the account and Region. A call to <code>TransactGetItems</code> cannot retrieve 2689 * items from tables in more than one AWS account or Region. The aggregate size of 2690 * the items in the transaction cannot exceed 4 MB.</p> <p>DynamoDB rejects the 2691 * entire <code>TransactGetItems</code> request if any of the following is 2692 * true:</p> <ul> <li> <p>A conflicting operation is in the process of updating an 2693 * item to be read.</p> </li> <li> <p>There is insufficient provisioned capacity 2694 * for the transaction to be completed.</p> </li> <li> <p>There is a user error, 2695 * such as an invalid data format.</p> </li> <li> <p>The aggregate size of the 2696 * items in the transaction cannot exceed 4 MB.</p> </li> </ul><p><h3>See 2697 * Also:</h3> <a 2698 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/TransactGetItems">AWS 2699 * API Reference</a></p> 2700 * 2701 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2702 */ 2703 virtual void TransactGetItemsAsync(const Model::TransactGetItemsRequest& request, const TransactGetItemsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2704 2705 /** 2706 * <p> <code>TransactWriteItems</code> is a synchronous write operation that groups 2707 * up to 25 action requests. These actions can target items in different tables, 2708 * but not in different AWS accounts or Regions, and no two actions can target the 2709 * same item. For example, you cannot both <code>ConditionCheck</code> and 2710 * <code>Update</code> the same item. The aggregate size of the items in the 2711 * transaction cannot exceed 4 MB.</p> <p>The actions are completed atomically so 2712 * that either all of them succeed, or all of them fail. They are defined by the 2713 * following objects:</p> <ul> <li> <p> <code>Put</code> — Initiates a 2714 * <code>PutItem</code> operation to write a new item. This structure specifies the 2715 * primary key of the item to be written, the name of the table to write it in, an 2716 * optional condition expression that must be satisfied for the write to succeed, a 2717 * list of the item's attributes, and a field indicating whether to retrieve the 2718 * item's attributes if the condition is not met.</p> </li> <li> <p> 2719 * <code>Update</code> — Initiates an <code>UpdateItem</code> operation to 2720 * update an existing item. This structure specifies the primary key of the item to 2721 * be updated, the name of the table where it resides, an optional condition 2722 * expression that must be satisfied for the update to succeed, an expression that 2723 * defines one or more attributes to be updated, and a field indicating whether to 2724 * retrieve the item's attributes if the condition is not met.</p> </li> <li> <p> 2725 * <code>Delete</code> — Initiates a <code>DeleteItem</code> operation to 2726 * delete an existing item. This structure specifies the primary key of the item to 2727 * be deleted, the name of the table where it resides, an optional condition 2728 * expression that must be satisfied for the deletion to succeed, and a field 2729 * indicating whether to retrieve the item's attributes if the condition is not 2730 * met.</p> </li> <li> <p> <code>ConditionCheck</code> — Applies a 2731 * condition to an item that is not being modified by the transaction. This 2732 * structure specifies the primary key of the item to be checked, the name of the 2733 * table where it resides, a condition expression that must be satisfied for the 2734 * transaction to succeed, and a field indicating whether to retrieve the item's 2735 * attributes if the condition is not met.</p> </li> </ul> <p>DynamoDB rejects the 2736 * entire <code>TransactWriteItems</code> request if any of the following is 2737 * true:</p> <ul> <li> <p>A condition in one of the condition expressions is not 2738 * met.</p> </li> <li> <p>An ongoing operation is in the process of updating the 2739 * same item.</p> </li> <li> <p>There is insufficient provisioned capacity for the 2740 * transaction to be completed.</p> </li> <li> <p>An item size becomes too large 2741 * (bigger than 400 KB), a local secondary index (LSI) becomes too large, or a 2742 * similar validation error occurs because of changes made by the transaction.</p> 2743 * </li> <li> <p>The aggregate size of the items in the transaction exceeds 4 2744 * MB.</p> </li> <li> <p>There is a user error, such as an invalid data format.</p> 2745 * </li> </ul><p><h3>See Also:</h3> <a 2746 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/TransactWriteItems">AWS 2747 * API Reference</a></p> 2748 */ 2749 virtual Model::TransactWriteItemsOutcome TransactWriteItems(const Model::TransactWriteItemsRequest& request) const; 2750 2751 /** 2752 * <p> <code>TransactWriteItems</code> is a synchronous write operation that groups 2753 * up to 25 action requests. These actions can target items in different tables, 2754 * but not in different AWS accounts or Regions, and no two actions can target the 2755 * same item. For example, you cannot both <code>ConditionCheck</code> and 2756 * <code>Update</code> the same item. The aggregate size of the items in the 2757 * transaction cannot exceed 4 MB.</p> <p>The actions are completed atomically so 2758 * that either all of them succeed, or all of them fail. They are defined by the 2759 * following objects:</p> <ul> <li> <p> <code>Put</code> — Initiates a 2760 * <code>PutItem</code> operation to write a new item. This structure specifies the 2761 * primary key of the item to be written, the name of the table to write it in, an 2762 * optional condition expression that must be satisfied for the write to succeed, a 2763 * list of the item's attributes, and a field indicating whether to retrieve the 2764 * item's attributes if the condition is not met.</p> </li> <li> <p> 2765 * <code>Update</code> — Initiates an <code>UpdateItem</code> operation to 2766 * update an existing item. This structure specifies the primary key of the item to 2767 * be updated, the name of the table where it resides, an optional condition 2768 * expression that must be satisfied for the update to succeed, an expression that 2769 * defines one or more attributes to be updated, and a field indicating whether to 2770 * retrieve the item's attributes if the condition is not met.</p> </li> <li> <p> 2771 * <code>Delete</code> — Initiates a <code>DeleteItem</code> operation to 2772 * delete an existing item. This structure specifies the primary key of the item to 2773 * be deleted, the name of the table where it resides, an optional condition 2774 * expression that must be satisfied for the deletion to succeed, and a field 2775 * indicating whether to retrieve the item's attributes if the condition is not 2776 * met.</p> </li> <li> <p> <code>ConditionCheck</code> — Applies a 2777 * condition to an item that is not being modified by the transaction. This 2778 * structure specifies the primary key of the item to be checked, the name of the 2779 * table where it resides, a condition expression that must be satisfied for the 2780 * transaction to succeed, and a field indicating whether to retrieve the item's 2781 * attributes if the condition is not met.</p> </li> </ul> <p>DynamoDB rejects the 2782 * entire <code>TransactWriteItems</code> request if any of the following is 2783 * true:</p> <ul> <li> <p>A condition in one of the condition expressions is not 2784 * met.</p> </li> <li> <p>An ongoing operation is in the process of updating the 2785 * same item.</p> </li> <li> <p>There is insufficient provisioned capacity for the 2786 * transaction to be completed.</p> </li> <li> <p>An item size becomes too large 2787 * (bigger than 400 KB), a local secondary index (LSI) becomes too large, or a 2788 * similar validation error occurs because of changes made by the transaction.</p> 2789 * </li> <li> <p>The aggregate size of the items in the transaction exceeds 4 2790 * MB.</p> </li> <li> <p>There is a user error, such as an invalid data format.</p> 2791 * </li> </ul><p><h3>See Also:</h3> <a 2792 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/TransactWriteItems">AWS 2793 * API Reference</a></p> 2794 * 2795 * returns a future to the operation so that it can be executed in parallel to other requests. 2796 */ 2797 virtual Model::TransactWriteItemsOutcomeCallable TransactWriteItemsCallable(const Model::TransactWriteItemsRequest& request) const; 2798 2799 /** 2800 * <p> <code>TransactWriteItems</code> is a synchronous write operation that groups 2801 * up to 25 action requests. These actions can target items in different tables, 2802 * but not in different AWS accounts or Regions, and no two actions can target the 2803 * same item. For example, you cannot both <code>ConditionCheck</code> and 2804 * <code>Update</code> the same item. The aggregate size of the items in the 2805 * transaction cannot exceed 4 MB.</p> <p>The actions are completed atomically so 2806 * that either all of them succeed, or all of them fail. They are defined by the 2807 * following objects:</p> <ul> <li> <p> <code>Put</code> — Initiates a 2808 * <code>PutItem</code> operation to write a new item. This structure specifies the 2809 * primary key of the item to be written, the name of the table to write it in, an 2810 * optional condition expression that must be satisfied for the write to succeed, a 2811 * list of the item's attributes, and a field indicating whether to retrieve the 2812 * item's attributes if the condition is not met.</p> </li> <li> <p> 2813 * <code>Update</code> — Initiates an <code>UpdateItem</code> operation to 2814 * update an existing item. This structure specifies the primary key of the item to 2815 * be updated, the name of the table where it resides, an optional condition 2816 * expression that must be satisfied for the update to succeed, an expression that 2817 * defines one or more attributes to be updated, and a field indicating whether to 2818 * retrieve the item's attributes if the condition is not met.</p> </li> <li> <p> 2819 * <code>Delete</code> — Initiates a <code>DeleteItem</code> operation to 2820 * delete an existing item. This structure specifies the primary key of the item to 2821 * be deleted, the name of the table where it resides, an optional condition 2822 * expression that must be satisfied for the deletion to succeed, and a field 2823 * indicating whether to retrieve the item's attributes if the condition is not 2824 * met.</p> </li> <li> <p> <code>ConditionCheck</code> — Applies a 2825 * condition to an item that is not being modified by the transaction. This 2826 * structure specifies the primary key of the item to be checked, the name of the 2827 * table where it resides, a condition expression that must be satisfied for the 2828 * transaction to succeed, and a field indicating whether to retrieve the item's 2829 * attributes if the condition is not met.</p> </li> </ul> <p>DynamoDB rejects the 2830 * entire <code>TransactWriteItems</code> request if any of the following is 2831 * true:</p> <ul> <li> <p>A condition in one of the condition expressions is not 2832 * met.</p> </li> <li> <p>An ongoing operation is in the process of updating the 2833 * same item.</p> </li> <li> <p>There is insufficient provisioned capacity for the 2834 * transaction to be completed.</p> </li> <li> <p>An item size becomes too large 2835 * (bigger than 400 KB), a local secondary index (LSI) becomes too large, or a 2836 * similar validation error occurs because of changes made by the transaction.</p> 2837 * </li> <li> <p>The aggregate size of the items in the transaction exceeds 4 2838 * MB.</p> </li> <li> <p>There is a user error, such as an invalid data format.</p> 2839 * </li> </ul><p><h3>See Also:</h3> <a 2840 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/TransactWriteItems">AWS 2841 * API Reference</a></p> 2842 * 2843 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2844 */ 2845 virtual void TransactWriteItemsAsync(const Model::TransactWriteItemsRequest& request, const TransactWriteItemsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2846 2847 /** 2848 * <p>Removes the association of tags from an Amazon DynamoDB resource. You can 2849 * call <code>UntagResource</code> up to five times per second, per account. </p> 2850 * <p>For an overview on tagging DynamoDB resources, see <a 2851 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html">Tagging 2852 * for DynamoDB</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><p><h3>See 2853 * Also:</h3> <a 2854 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UntagResource">AWS 2855 * API Reference</a></p> 2856 */ 2857 virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; 2858 2859 /** 2860 * <p>Removes the association of tags from an Amazon DynamoDB resource. You can 2861 * call <code>UntagResource</code> up to five times per second, per account. </p> 2862 * <p>For an overview on tagging DynamoDB resources, see <a 2863 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html">Tagging 2864 * for DynamoDB</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><p><h3>See 2865 * Also:</h3> <a 2866 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UntagResource">AWS 2867 * API Reference</a></p> 2868 * 2869 * returns a future to the operation so that it can be executed in parallel to other requests. 2870 */ 2871 virtual Model::UntagResourceOutcomeCallable UntagResourceCallable(const Model::UntagResourceRequest& request) const; 2872 2873 /** 2874 * <p>Removes the association of tags from an Amazon DynamoDB resource. You can 2875 * call <code>UntagResource</code> up to five times per second, per account. </p> 2876 * <p>For an overview on tagging DynamoDB resources, see <a 2877 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html">Tagging 2878 * for DynamoDB</a> in the <i>Amazon DynamoDB Developer Guide</i>.</p><p><h3>See 2879 * Also:</h3> <a 2880 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UntagResource">AWS 2881 * API Reference</a></p> 2882 * 2883 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2884 */ 2885 virtual void UntagResourceAsync(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2886 2887 /** 2888 * <p> <code>UpdateContinuousBackups</code> enables or disables point in time 2889 * recovery for the specified table. A successful 2890 * <code>UpdateContinuousBackups</code> call returns the current 2891 * <code>ContinuousBackupsDescription</code>. Continuous backups are 2892 * <code>ENABLED</code> on all tables at table creation. If point in time recovery 2893 * is enabled, <code>PointInTimeRecoveryStatus</code> will be set to ENABLED.</p> 2894 * <p> Once continuous backups and point in time recovery are enabled, you can 2895 * restore to any point in time within <code>EarliestRestorableDateTime</code> and 2896 * <code>LatestRestorableDateTime</code>. </p> <p> 2897 * <code>LatestRestorableDateTime</code> is typically 5 minutes before the current 2898 * time. You can restore your table to any point in time during the last 35 days. 2899 * </p><p><h3>See Also:</h3> <a 2900 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateContinuousBackups">AWS 2901 * API Reference</a></p> 2902 */ 2903 virtual Model::UpdateContinuousBackupsOutcome UpdateContinuousBackups(const Model::UpdateContinuousBackupsRequest& request) const; 2904 2905 /** 2906 * <p> <code>UpdateContinuousBackups</code> enables or disables point in time 2907 * recovery for the specified table. A successful 2908 * <code>UpdateContinuousBackups</code> call returns the current 2909 * <code>ContinuousBackupsDescription</code>. Continuous backups are 2910 * <code>ENABLED</code> on all tables at table creation. If point in time recovery 2911 * is enabled, <code>PointInTimeRecoveryStatus</code> will be set to ENABLED.</p> 2912 * <p> Once continuous backups and point in time recovery are enabled, you can 2913 * restore to any point in time within <code>EarliestRestorableDateTime</code> and 2914 * <code>LatestRestorableDateTime</code>. </p> <p> 2915 * <code>LatestRestorableDateTime</code> is typically 5 minutes before the current 2916 * time. You can restore your table to any point in time during the last 35 days. 2917 * </p><p><h3>See Also:</h3> <a 2918 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateContinuousBackups">AWS 2919 * API Reference</a></p> 2920 * 2921 * returns a future to the operation so that it can be executed in parallel to other requests. 2922 */ 2923 virtual Model::UpdateContinuousBackupsOutcomeCallable UpdateContinuousBackupsCallable(const Model::UpdateContinuousBackupsRequest& request) const; 2924 2925 /** 2926 * <p> <code>UpdateContinuousBackups</code> enables or disables point in time 2927 * recovery for the specified table. A successful 2928 * <code>UpdateContinuousBackups</code> call returns the current 2929 * <code>ContinuousBackupsDescription</code>. Continuous backups are 2930 * <code>ENABLED</code> on all tables at table creation. If point in time recovery 2931 * is enabled, <code>PointInTimeRecoveryStatus</code> will be set to ENABLED.</p> 2932 * <p> Once continuous backups and point in time recovery are enabled, you can 2933 * restore to any point in time within <code>EarliestRestorableDateTime</code> and 2934 * <code>LatestRestorableDateTime</code>. </p> <p> 2935 * <code>LatestRestorableDateTime</code> is typically 5 minutes before the current 2936 * time. You can restore your table to any point in time during the last 35 days. 2937 * </p><p><h3>See Also:</h3> <a 2938 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateContinuousBackups">AWS 2939 * API Reference</a></p> 2940 * 2941 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2942 */ 2943 virtual void UpdateContinuousBackupsAsync(const Model::UpdateContinuousBackupsRequest& request, const UpdateContinuousBackupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2944 2945 /** 2946 * <p>Updates the status for contributor insights for a specific table or 2947 * index.</p><p><h3>See Also:</h3> <a 2948 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateContributorInsights">AWS 2949 * API Reference</a></p> 2950 */ 2951 virtual Model::UpdateContributorInsightsOutcome UpdateContributorInsights(const Model::UpdateContributorInsightsRequest& request) const; 2952 2953 /** 2954 * <p>Updates the status for contributor insights for a specific table or 2955 * index.</p><p><h3>See Also:</h3> <a 2956 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateContributorInsights">AWS 2957 * API Reference</a></p> 2958 * 2959 * returns a future to the operation so that it can be executed in parallel to other requests. 2960 */ 2961 virtual Model::UpdateContributorInsightsOutcomeCallable UpdateContributorInsightsCallable(const Model::UpdateContributorInsightsRequest& request) const; 2962 2963 /** 2964 * <p>Updates the status for contributor insights for a specific table or 2965 * index.</p><p><h3>See Also:</h3> <a 2966 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateContributorInsights">AWS 2967 * API Reference</a></p> 2968 * 2969 * Queues the request into a thread executor and triggers associated callback when operation has finished. 2970 */ 2971 virtual void UpdateContributorInsightsAsync(const Model::UpdateContributorInsightsRequest& request, const UpdateContributorInsightsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 2972 2973 /** 2974 * <p>Adds or removes replicas in the specified global table. The global table must 2975 * already exist to be able to use this operation. Any replica to be added must be 2976 * empty, have the same name as the global table, have the same key schema, have 2977 * DynamoDB Streams enabled, and have the same provisioned and maximum write 2978 * capacity units.</p> <p>Although you can use 2979 * <code>UpdateGlobalTable</code> to add replicas and remove replicas in a single 2980 * request, for simplicity we recommend that you issue separate requests for adding 2981 * or removing replicas.</p> <p> If global secondary indexes are specified, 2982 * then the following conditions must also be met: </p> <ul> <li> <p> The global 2983 * secondary indexes must have the same name. </p> </li> <li> <p> The global 2984 * secondary indexes must have the same hash key and sort key (if present). </p> 2985 * </li> <li> <p> The global secondary indexes must have the same provisioned and 2986 * maximum write capacity units. </p> </li> </ul><p><h3>See Also:</h3> <a 2987 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateGlobalTable">AWS 2988 * API Reference</a></p> 2989 */ 2990 virtual Model::UpdateGlobalTableOutcome UpdateGlobalTable(const Model::UpdateGlobalTableRequest& request) const; 2991 2992 /** 2993 * <p>Adds or removes replicas in the specified global table. The global table must 2994 * already exist to be able to use this operation. Any replica to be added must be 2995 * empty, have the same name as the global table, have the same key schema, have 2996 * DynamoDB Streams enabled, and have the same provisioned and maximum write 2997 * capacity units.</p> <p>Although you can use 2998 * <code>UpdateGlobalTable</code> to add replicas and remove replicas in a single 2999 * request, for simplicity we recommend that you issue separate requests for adding 3000 * or removing replicas.</p> <p> If global secondary indexes are specified, 3001 * then the following conditions must also be met: </p> <ul> <li> <p> The global 3002 * secondary indexes must have the same name. </p> </li> <li> <p> The global 3003 * secondary indexes must have the same hash key and sort key (if present). </p> 3004 * </li> <li> <p> The global secondary indexes must have the same provisioned and 3005 * maximum write capacity units. </p> </li> </ul><p><h3>See Also:</h3> <a 3006 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateGlobalTable">AWS 3007 * API Reference</a></p> 3008 * 3009 * returns a future to the operation so that it can be executed in parallel to other requests. 3010 */ 3011 virtual Model::UpdateGlobalTableOutcomeCallable UpdateGlobalTableCallable(const Model::UpdateGlobalTableRequest& request) const; 3012 3013 /** 3014 * <p>Adds or removes replicas in the specified global table. The global table must 3015 * already exist to be able to use this operation. Any replica to be added must be 3016 * empty, have the same name as the global table, have the same key schema, have 3017 * DynamoDB Streams enabled, and have the same provisioned and maximum write 3018 * capacity units.</p> <p>Although you can use 3019 * <code>UpdateGlobalTable</code> to add replicas and remove replicas in a single 3020 * request, for simplicity we recommend that you issue separate requests for adding 3021 * or removing replicas.</p> <p> If global secondary indexes are specified, 3022 * then the following conditions must also be met: </p> <ul> <li> <p> The global 3023 * secondary indexes must have the same name. </p> </li> <li> <p> The global 3024 * secondary indexes must have the same hash key and sort key (if present). </p> 3025 * </li> <li> <p> The global secondary indexes must have the same provisioned and 3026 * maximum write capacity units. </p> </li> </ul><p><h3>See Also:</h3> <a 3027 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateGlobalTable">AWS 3028 * API Reference</a></p> 3029 * 3030 * Queues the request into a thread executor and triggers associated callback when operation has finished. 3031 */ 3032 virtual void UpdateGlobalTableAsync(const Model::UpdateGlobalTableRequest& request, const UpdateGlobalTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 3033 3034 /** 3035 * <p>Updates settings for a global table.</p><p><h3>See Also:</h3> <a 3036 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateGlobalTableSettings">AWS 3037 * API Reference</a></p> 3038 */ 3039 virtual Model::UpdateGlobalTableSettingsOutcome UpdateGlobalTableSettings(const Model::UpdateGlobalTableSettingsRequest& request) const; 3040 3041 /** 3042 * <p>Updates settings for a global table.</p><p><h3>See Also:</h3> <a 3043 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateGlobalTableSettings">AWS 3044 * API Reference</a></p> 3045 * 3046 * returns a future to the operation so that it can be executed in parallel to other requests. 3047 */ 3048 virtual Model::UpdateGlobalTableSettingsOutcomeCallable UpdateGlobalTableSettingsCallable(const Model::UpdateGlobalTableSettingsRequest& request) const; 3049 3050 /** 3051 * <p>Updates settings for a global table.</p><p><h3>See Also:</h3> <a 3052 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateGlobalTableSettings">AWS 3053 * API Reference</a></p> 3054 * 3055 * Queues the request into a thread executor and triggers associated callback when operation has finished. 3056 */ 3057 virtual void UpdateGlobalTableSettingsAsync(const Model::UpdateGlobalTableSettingsRequest& request, const UpdateGlobalTableSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 3058 3059 /** 3060 * <p>Edits an existing item's attributes, or adds a new item to the table if it 3061 * does not already exist. You can put, delete, or add attribute values. You can 3062 * also perform a conditional update on an existing item (insert a new attribute 3063 * name-value pair if it doesn't exist, or replace an existing name-value pair if 3064 * it has certain expected attribute values).</p> <p>You can also return the item's 3065 * attribute values in the same <code>UpdateItem</code> operation using the 3066 * <code>ReturnValues</code> parameter.</p><p><h3>See Also:</h3> <a 3067 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateItem">AWS 3068 * API Reference</a></p> 3069 */ 3070 virtual Model::UpdateItemOutcome UpdateItem(const Model::UpdateItemRequest& request) const; 3071 3072 /** 3073 * <p>Edits an existing item's attributes, or adds a new item to the table if it 3074 * does not already exist. You can put, delete, or add attribute values. You can 3075 * also perform a conditional update on an existing item (insert a new attribute 3076 * name-value pair if it doesn't exist, or replace an existing name-value pair if 3077 * it has certain expected attribute values).</p> <p>You can also return the item's 3078 * attribute values in the same <code>UpdateItem</code> operation using the 3079 * <code>ReturnValues</code> parameter.</p><p><h3>See Also:</h3> <a 3080 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateItem">AWS 3081 * API Reference</a></p> 3082 * 3083 * returns a future to the operation so that it can be executed in parallel to other requests. 3084 */ 3085 virtual Model::UpdateItemOutcomeCallable UpdateItemCallable(const Model::UpdateItemRequest& request) const; 3086 3087 /** 3088 * <p>Edits an existing item's attributes, or adds a new item to the table if it 3089 * does not already exist. You can put, delete, or add attribute values. You can 3090 * also perform a conditional update on an existing item (insert a new attribute 3091 * name-value pair if it doesn't exist, or replace an existing name-value pair if 3092 * it has certain expected attribute values).</p> <p>You can also return the item's 3093 * attribute values in the same <code>UpdateItem</code> operation using the 3094 * <code>ReturnValues</code> parameter.</p><p><h3>See Also:</h3> <a 3095 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateItem">AWS 3096 * API Reference</a></p> 3097 * 3098 * Queues the request into a thread executor and triggers associated callback when operation has finished. 3099 */ 3100 virtual void UpdateItemAsync(const Model::UpdateItemRequest& request, const UpdateItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 3101 3102 /** 3103 * <p>Modifies the provisioned throughput settings, global secondary indexes, or 3104 * DynamoDB Streams settings for a given table.</p> <p>You can only perform one of 3105 * the following operations at once:</p> <ul> <li> <p>Modify the provisioned 3106 * throughput settings of the table.</p> </li> <li> <p>Enable or disable DynamoDB 3107 * Streams on the table.</p> </li> <li> <p>Remove a global secondary index from the 3108 * table.</p> </li> <li> <p>Create a new global secondary index on the table. After 3109 * the index begins backfilling, you can use <code>UpdateTable</code> to perform 3110 * other operations.</p> </li> </ul> <p> <code>UpdateTable</code> is an 3111 * asynchronous operation; while it is executing, the table status changes from 3112 * <code>ACTIVE</code> to <code>UPDATING</code>. While it is <code>UPDATING</code>, 3113 * you cannot issue another <code>UpdateTable</code> request. When the table 3114 * returns to the <code>ACTIVE</code> state, the <code>UpdateTable</code> operation 3115 * is complete.</p><p><h3>See Also:</h3> <a 3116 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateTable">AWS 3117 * API Reference</a></p> 3118 */ 3119 virtual Model::UpdateTableOutcome UpdateTable(const Model::UpdateTableRequest& request) const; 3120 3121 /** 3122 * <p>Modifies the provisioned throughput settings, global secondary indexes, or 3123 * DynamoDB Streams settings for a given table.</p> <p>You can only perform one of 3124 * the following operations at once:</p> <ul> <li> <p>Modify the provisioned 3125 * throughput settings of the table.</p> </li> <li> <p>Enable or disable DynamoDB 3126 * Streams on the table.</p> </li> <li> <p>Remove a global secondary index from the 3127 * table.</p> </li> <li> <p>Create a new global secondary index on the table. After 3128 * the index begins backfilling, you can use <code>UpdateTable</code> to perform 3129 * other operations.</p> </li> </ul> <p> <code>UpdateTable</code> is an 3130 * asynchronous operation; while it is executing, the table status changes from 3131 * <code>ACTIVE</code> to <code>UPDATING</code>. While it is <code>UPDATING</code>, 3132 * you cannot issue another <code>UpdateTable</code> request. When the table 3133 * returns to the <code>ACTIVE</code> state, the <code>UpdateTable</code> operation 3134 * is complete.</p><p><h3>See Also:</h3> <a 3135 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateTable">AWS 3136 * API Reference</a></p> 3137 * 3138 * returns a future to the operation so that it can be executed in parallel to other requests. 3139 */ 3140 virtual Model::UpdateTableOutcomeCallable UpdateTableCallable(const Model::UpdateTableRequest& request) const; 3141 3142 /** 3143 * <p>Modifies the provisioned throughput settings, global secondary indexes, or 3144 * DynamoDB Streams settings for a given table.</p> <p>You can only perform one of 3145 * the following operations at once:</p> <ul> <li> <p>Modify the provisioned 3146 * throughput settings of the table.</p> </li> <li> <p>Enable or disable DynamoDB 3147 * Streams on the table.</p> </li> <li> <p>Remove a global secondary index from the 3148 * table.</p> </li> <li> <p>Create a new global secondary index on the table. After 3149 * the index begins backfilling, you can use <code>UpdateTable</code> to perform 3150 * other operations.</p> </li> </ul> <p> <code>UpdateTable</code> is an 3151 * asynchronous operation; while it is executing, the table status changes from 3152 * <code>ACTIVE</code> to <code>UPDATING</code>. While it is <code>UPDATING</code>, 3153 * you cannot issue another <code>UpdateTable</code> request. When the table 3154 * returns to the <code>ACTIVE</code> state, the <code>UpdateTable</code> operation 3155 * is complete.</p><p><h3>See Also:</h3> <a 3156 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateTable">AWS 3157 * API Reference</a></p> 3158 * 3159 * Queues the request into a thread executor and triggers associated callback when operation has finished. 3160 */ 3161 virtual void UpdateTableAsync(const Model::UpdateTableRequest& request, const UpdateTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 3162 3163 /** 3164 * <p>Updates auto scaling settings on your global tables at once.</p> 3165 * <p>This operation only applies to <a 3166 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 3167 * 2019.11.21</a> of global tables.</p> <p><h3>See Also:</h3> <a 3168 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateTableReplicaAutoScaling">AWS 3169 * API Reference</a></p> 3170 */ 3171 virtual Model::UpdateTableReplicaAutoScalingOutcome UpdateTableReplicaAutoScaling(const Model::UpdateTableReplicaAutoScalingRequest& request) const; 3172 3173 /** 3174 * <p>Updates auto scaling settings on your global tables at once.</p> 3175 * <p>This operation only applies to <a 3176 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 3177 * 2019.11.21</a> of global tables.</p> <p><h3>See Also:</h3> <a 3178 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateTableReplicaAutoScaling">AWS 3179 * API Reference</a></p> 3180 * 3181 * returns a future to the operation so that it can be executed in parallel to other requests. 3182 */ 3183 virtual Model::UpdateTableReplicaAutoScalingOutcomeCallable UpdateTableReplicaAutoScalingCallable(const Model::UpdateTableReplicaAutoScalingRequest& request) const; 3184 3185 /** 3186 * <p>Updates auto scaling settings on your global tables at once.</p> 3187 * <p>This operation only applies to <a 3188 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html">Version 3189 * 2019.11.21</a> of global tables.</p> <p><h3>See Also:</h3> <a 3190 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateTableReplicaAutoScaling">AWS 3191 * API Reference</a></p> 3192 * 3193 * Queues the request into a thread executor and triggers associated callback when operation has finished. 3194 */ 3195 virtual void UpdateTableReplicaAutoScalingAsync(const Model::UpdateTableReplicaAutoScalingRequest& request, const UpdateTableReplicaAutoScalingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 3196 3197 /** 3198 * <p>The <code>UpdateTimeToLive</code> method enables or disables Time to Live 3199 * (TTL) for the specified table. A successful <code>UpdateTimeToLive</code> call 3200 * returns the current <code>TimeToLiveSpecification</code>. It can take up to one 3201 * hour for the change to fully process. Any additional 3202 * <code>UpdateTimeToLive</code> calls for the same table during this one hour 3203 * duration result in a <code>ValidationException</code>. </p> <p>TTL compares the 3204 * current time in epoch time format to the time stored in the TTL attribute of an 3205 * item. If the epoch time value stored in the attribute is less than the current 3206 * time, the item is marked as expired and subsequently deleted.</p> <p> The 3207 * epoch time format is the number of seconds elapsed since 12:00:00 AM January 1, 3208 * 1970 UTC. </p> <p>DynamoDB deletes expired items on a best-effort basis 3209 * to ensure availability of throughput for other data operations. </p> 3210 * <p>DynamoDB typically deletes expired items within two days of expiration. The 3211 * exact duration within which an item gets deleted after expiration is specific to 3212 * the nature of the workload. Items that have expired and not been deleted will 3213 * still show up in reads, queries, and scans.</p> <p>As items are 3214 * deleted, they are removed from any local secondary index and global secondary 3215 * index immediately in the same eventually consistent way as a standard delete 3216 * operation.</p> <p>For more information, see <a 3217 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/TTL.html">Time 3218 * To Live</a> in the Amazon DynamoDB Developer Guide. </p><p><h3>See Also:</h3> 3219 * <a 3220 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateTimeToLive">AWS 3221 * API Reference</a></p> 3222 */ 3223 virtual Model::UpdateTimeToLiveOutcome UpdateTimeToLive(const Model::UpdateTimeToLiveRequest& request) const; 3224 3225 /** 3226 * <p>The <code>UpdateTimeToLive</code> method enables or disables Time to Live 3227 * (TTL) for the specified table. A successful <code>UpdateTimeToLive</code> call 3228 * returns the current <code>TimeToLiveSpecification</code>. It can take up to one 3229 * hour for the change to fully process. Any additional 3230 * <code>UpdateTimeToLive</code> calls for the same table during this one hour 3231 * duration result in a <code>ValidationException</code>. </p> <p>TTL compares the 3232 * current time in epoch time format to the time stored in the TTL attribute of an 3233 * item. If the epoch time value stored in the attribute is less than the current 3234 * time, the item is marked as expired and subsequently deleted.</p> <p> The 3235 * epoch time format is the number of seconds elapsed since 12:00:00 AM January 1, 3236 * 1970 UTC. </p> <p>DynamoDB deletes expired items on a best-effort basis 3237 * to ensure availability of throughput for other data operations. </p> 3238 * <p>DynamoDB typically deletes expired items within two days of expiration. The 3239 * exact duration within which an item gets deleted after expiration is specific to 3240 * the nature of the workload. Items that have expired and not been deleted will 3241 * still show up in reads, queries, and scans.</p> <p>As items are 3242 * deleted, they are removed from any local secondary index and global secondary 3243 * index immediately in the same eventually consistent way as a standard delete 3244 * operation.</p> <p>For more information, see <a 3245 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/TTL.html">Time 3246 * To Live</a> in the Amazon DynamoDB Developer Guide. </p><p><h3>See Also:</h3> 3247 * <a 3248 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateTimeToLive">AWS 3249 * API Reference</a></p> 3250 * 3251 * returns a future to the operation so that it can be executed in parallel to other requests. 3252 */ 3253 virtual Model::UpdateTimeToLiveOutcomeCallable UpdateTimeToLiveCallable(const Model::UpdateTimeToLiveRequest& request) const; 3254 3255 /** 3256 * <p>The <code>UpdateTimeToLive</code> method enables or disables Time to Live 3257 * (TTL) for the specified table. A successful <code>UpdateTimeToLive</code> call 3258 * returns the current <code>TimeToLiveSpecification</code>. It can take up to one 3259 * hour for the change to fully process. Any additional 3260 * <code>UpdateTimeToLive</code> calls for the same table during this one hour 3261 * duration result in a <code>ValidationException</code>. </p> <p>TTL compares the 3262 * current time in epoch time format to the time stored in the TTL attribute of an 3263 * item. If the epoch time value stored in the attribute is less than the current 3264 * time, the item is marked as expired and subsequently deleted.</p> <p> The 3265 * epoch time format is the number of seconds elapsed since 12:00:00 AM January 1, 3266 * 1970 UTC. </p> <p>DynamoDB deletes expired items on a best-effort basis 3267 * to ensure availability of throughput for other data operations. </p> 3268 * <p>DynamoDB typically deletes expired items within two days of expiration. The 3269 * exact duration within which an item gets deleted after expiration is specific to 3270 * the nature of the workload. Items that have expired and not been deleted will 3271 * still show up in reads, queries, and scans.</p> <p>As items are 3272 * deleted, they are removed from any local secondary index and global secondary 3273 * index immediately in the same eventually consistent way as a standard delete 3274 * operation.</p> <p>For more information, see <a 3275 * href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/TTL.html">Time 3276 * To Live</a> in the Amazon DynamoDB Developer Guide. </p><p><h3>See Also:</h3> 3277 * <a 3278 * href="http://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/UpdateTimeToLive">AWS 3279 * API Reference</a></p> 3280 * 3281 * Queues the request into a thread executor and triggers associated callback when operation has finished. 3282 */ 3283 virtual void UpdateTimeToLiveAsync(const Model::UpdateTimeToLiveRequest& request, const UpdateTimeToLiveResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const; 3284 3285 3286 void OverrideEndpoint(const Aws::String& endpoint); 3287 private: 3288 void init(const Aws::Client::ClientConfiguration& clientConfiguration); 3289 void LoadDynamoDBSpecificConfig(const Aws::Client::ClientConfiguration& clientConfiguration); 3290 void BatchExecuteStatementAsyncHelper(const Model::BatchExecuteStatementRequest& request, const BatchExecuteStatementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3291 void BatchGetItemAsyncHelper(const Model::BatchGetItemRequest& request, const BatchGetItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3292 void BatchWriteItemAsyncHelper(const Model::BatchWriteItemRequest& request, const BatchWriteItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3293 void CreateBackupAsyncHelper(const Model::CreateBackupRequest& request, const CreateBackupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3294 void CreateGlobalTableAsyncHelper(const Model::CreateGlobalTableRequest& request, const CreateGlobalTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3295 void CreateTableAsyncHelper(const Model::CreateTableRequest& request, const CreateTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3296 void DeleteBackupAsyncHelper(const Model::DeleteBackupRequest& request, const DeleteBackupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3297 void DeleteItemAsyncHelper(const Model::DeleteItemRequest& request, const DeleteItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3298 void DeleteTableAsyncHelper(const Model::DeleteTableRequest& request, const DeleteTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3299 void DescribeBackupAsyncHelper(const Model::DescribeBackupRequest& request, const DescribeBackupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3300 void DescribeContinuousBackupsAsyncHelper(const Model::DescribeContinuousBackupsRequest& request, const DescribeContinuousBackupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3301 void DescribeContributorInsightsAsyncHelper(const Model::DescribeContributorInsightsRequest& request, const DescribeContributorInsightsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3302 void DescribeEndpointsAsyncHelper(const Model::DescribeEndpointsRequest& request, const DescribeEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3303 void DescribeExportAsyncHelper(const Model::DescribeExportRequest& request, const DescribeExportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3304 void DescribeGlobalTableAsyncHelper(const Model::DescribeGlobalTableRequest& request, const DescribeGlobalTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3305 void DescribeGlobalTableSettingsAsyncHelper(const Model::DescribeGlobalTableSettingsRequest& request, const DescribeGlobalTableSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3306 void DescribeKinesisStreamingDestinationAsyncHelper(const Model::DescribeKinesisStreamingDestinationRequest& request, const DescribeKinesisStreamingDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3307 void DescribeLimitsAsyncHelper(const Model::DescribeLimitsRequest& request, const DescribeLimitsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3308 void DescribeTableAsyncHelper(const Model::DescribeTableRequest& request, const DescribeTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3309 void DescribeTableReplicaAutoScalingAsyncHelper(const Model::DescribeTableReplicaAutoScalingRequest& request, const DescribeTableReplicaAutoScalingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3310 void DescribeTimeToLiveAsyncHelper(const Model::DescribeTimeToLiveRequest& request, const DescribeTimeToLiveResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3311 void DisableKinesisStreamingDestinationAsyncHelper(const Model::DisableKinesisStreamingDestinationRequest& request, const DisableKinesisStreamingDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3312 void EnableKinesisStreamingDestinationAsyncHelper(const Model::EnableKinesisStreamingDestinationRequest& request, const EnableKinesisStreamingDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3313 void ExecuteStatementAsyncHelper(const Model::ExecuteStatementRequest& request, const ExecuteStatementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3314 void ExecuteTransactionAsyncHelper(const Model::ExecuteTransactionRequest& request, const ExecuteTransactionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3315 void ExportTableToPointInTimeAsyncHelper(const Model::ExportTableToPointInTimeRequest& request, const ExportTableToPointInTimeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3316 void GetItemAsyncHelper(const Model::GetItemRequest& request, const GetItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3317 void ListBackupsAsyncHelper(const Model::ListBackupsRequest& request, const ListBackupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3318 void ListContributorInsightsAsyncHelper(const Model::ListContributorInsightsRequest& request, const ListContributorInsightsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3319 void ListExportsAsyncHelper(const Model::ListExportsRequest& request, const ListExportsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3320 void ListGlobalTablesAsyncHelper(const Model::ListGlobalTablesRequest& request, const ListGlobalTablesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3321 void ListTablesAsyncHelper(const Model::ListTablesRequest& request, const ListTablesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3322 void ListTagsOfResourceAsyncHelper(const Model::ListTagsOfResourceRequest& request, const ListTagsOfResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3323 void PutItemAsyncHelper(const Model::PutItemRequest& request, const PutItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3324 void QueryAsyncHelper(const Model::QueryRequest& request, const QueryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3325 void RestoreTableFromBackupAsyncHelper(const Model::RestoreTableFromBackupRequest& request, const RestoreTableFromBackupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3326 void RestoreTableToPointInTimeAsyncHelper(const Model::RestoreTableToPointInTimeRequest& request, const RestoreTableToPointInTimeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3327 void ScanAsyncHelper(const Model::ScanRequest& request, const ScanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3328 void TagResourceAsyncHelper(const Model::TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3329 void TransactGetItemsAsyncHelper(const Model::TransactGetItemsRequest& request, const TransactGetItemsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3330 void TransactWriteItemsAsyncHelper(const Model::TransactWriteItemsRequest& request, const TransactWriteItemsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3331 void UntagResourceAsyncHelper(const Model::UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3332 void UpdateContinuousBackupsAsyncHelper(const Model::UpdateContinuousBackupsRequest& request, const UpdateContinuousBackupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3333 void UpdateContributorInsightsAsyncHelper(const Model::UpdateContributorInsightsRequest& request, const UpdateContributorInsightsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3334 void UpdateGlobalTableAsyncHelper(const Model::UpdateGlobalTableRequest& request, const UpdateGlobalTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3335 void UpdateGlobalTableSettingsAsyncHelper(const Model::UpdateGlobalTableSettingsRequest& request, const UpdateGlobalTableSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3336 void UpdateItemAsyncHelper(const Model::UpdateItemRequest& request, const UpdateItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3337 void UpdateTableAsyncHelper(const Model::UpdateTableRequest& request, const UpdateTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3338 void UpdateTableReplicaAutoScalingAsyncHelper(const Model::UpdateTableReplicaAutoScalingRequest& request, const UpdateTableReplicaAutoScalingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3339 void UpdateTimeToLiveAsyncHelper(const Model::UpdateTimeToLiveRequest& request, const UpdateTimeToLiveResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const; 3340 3341 Aws::String m_uri; 3342 mutable Aws::Utils::ConcurrentCache<Aws::String, Aws::String> m_endpointsCache; 3343 bool m_enableEndpointDiscovery; 3344 Aws::String m_configScheme; 3345 std::shared_ptr<Aws::Utils::Threading::Executor> m_executor; 3346 }; 3347 3348 } // namespace DynamoDB 3349 } // namespace Aws 3350