software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient Maven / Gradle / Ivy
/*
* Copyright 2013-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package software.amazon.awssdk.services.dynamodb;
import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;
import software.amazon.awssdk.annotations.Generated;
import software.amazon.awssdk.core.SdkClient;
import software.amazon.awssdk.services.dynamodb.model.BatchGetItemRequest;
import software.amazon.awssdk.services.dynamodb.model.BatchGetItemResponse;
import software.amazon.awssdk.services.dynamodb.model.BatchWriteItemRequest;
import software.amazon.awssdk.services.dynamodb.model.BatchWriteItemResponse;
import software.amazon.awssdk.services.dynamodb.model.CreateBackupRequest;
import software.amazon.awssdk.services.dynamodb.model.CreateBackupResponse;
import software.amazon.awssdk.services.dynamodb.model.CreateGlobalTableRequest;
import software.amazon.awssdk.services.dynamodb.model.CreateGlobalTableResponse;
import software.amazon.awssdk.services.dynamodb.model.CreateTableRequest;
import software.amazon.awssdk.services.dynamodb.model.CreateTableResponse;
import software.amazon.awssdk.services.dynamodb.model.DeleteBackupRequest;
import software.amazon.awssdk.services.dynamodb.model.DeleteBackupResponse;
import software.amazon.awssdk.services.dynamodb.model.DeleteItemRequest;
import software.amazon.awssdk.services.dynamodb.model.DeleteItemResponse;
import software.amazon.awssdk.services.dynamodb.model.DeleteTableRequest;
import software.amazon.awssdk.services.dynamodb.model.DeleteTableResponse;
import software.amazon.awssdk.services.dynamodb.model.DescribeBackupRequest;
import software.amazon.awssdk.services.dynamodb.model.DescribeBackupResponse;
import software.amazon.awssdk.services.dynamodb.model.DescribeContinuousBackupsRequest;
import software.amazon.awssdk.services.dynamodb.model.DescribeContinuousBackupsResponse;
import software.amazon.awssdk.services.dynamodb.model.DescribeGlobalTableRequest;
import software.amazon.awssdk.services.dynamodb.model.DescribeGlobalTableResponse;
import software.amazon.awssdk.services.dynamodb.model.DescribeGlobalTableSettingsRequest;
import software.amazon.awssdk.services.dynamodb.model.DescribeGlobalTableSettingsResponse;
import software.amazon.awssdk.services.dynamodb.model.DescribeLimitsRequest;
import software.amazon.awssdk.services.dynamodb.model.DescribeLimitsResponse;
import software.amazon.awssdk.services.dynamodb.model.DescribeTableRequest;
import software.amazon.awssdk.services.dynamodb.model.DescribeTableResponse;
import software.amazon.awssdk.services.dynamodb.model.DescribeTimeToLiveRequest;
import software.amazon.awssdk.services.dynamodb.model.DescribeTimeToLiveResponse;
import software.amazon.awssdk.services.dynamodb.model.GetItemRequest;
import software.amazon.awssdk.services.dynamodb.model.GetItemResponse;
import software.amazon.awssdk.services.dynamodb.model.ListBackupsRequest;
import software.amazon.awssdk.services.dynamodb.model.ListBackupsResponse;
import software.amazon.awssdk.services.dynamodb.model.ListGlobalTablesRequest;
import software.amazon.awssdk.services.dynamodb.model.ListGlobalTablesResponse;
import software.amazon.awssdk.services.dynamodb.model.ListTablesRequest;
import software.amazon.awssdk.services.dynamodb.model.ListTablesResponse;
import software.amazon.awssdk.services.dynamodb.model.ListTagsOfResourceRequest;
import software.amazon.awssdk.services.dynamodb.model.ListTagsOfResourceResponse;
import software.amazon.awssdk.services.dynamodb.model.PutItemRequest;
import software.amazon.awssdk.services.dynamodb.model.PutItemResponse;
import software.amazon.awssdk.services.dynamodb.model.QueryRequest;
import software.amazon.awssdk.services.dynamodb.model.QueryResponse;
import software.amazon.awssdk.services.dynamodb.model.RestoreTableFromBackupRequest;
import software.amazon.awssdk.services.dynamodb.model.RestoreTableFromBackupResponse;
import software.amazon.awssdk.services.dynamodb.model.RestoreTableToPointInTimeRequest;
import software.amazon.awssdk.services.dynamodb.model.RestoreTableToPointInTimeResponse;
import software.amazon.awssdk.services.dynamodb.model.ScanRequest;
import software.amazon.awssdk.services.dynamodb.model.ScanResponse;
import software.amazon.awssdk.services.dynamodb.model.TagResourceRequest;
import software.amazon.awssdk.services.dynamodb.model.TagResourceResponse;
import software.amazon.awssdk.services.dynamodb.model.UntagResourceRequest;
import software.amazon.awssdk.services.dynamodb.model.UntagResourceResponse;
import software.amazon.awssdk.services.dynamodb.model.UpdateContinuousBackupsRequest;
import software.amazon.awssdk.services.dynamodb.model.UpdateContinuousBackupsResponse;
import software.amazon.awssdk.services.dynamodb.model.UpdateGlobalTableRequest;
import software.amazon.awssdk.services.dynamodb.model.UpdateGlobalTableResponse;
import software.amazon.awssdk.services.dynamodb.model.UpdateGlobalTableSettingsRequest;
import software.amazon.awssdk.services.dynamodb.model.UpdateGlobalTableSettingsResponse;
import software.amazon.awssdk.services.dynamodb.model.UpdateItemRequest;
import software.amazon.awssdk.services.dynamodb.model.UpdateItemResponse;
import software.amazon.awssdk.services.dynamodb.model.UpdateTableRequest;
import software.amazon.awssdk.services.dynamodb.model.UpdateTableResponse;
import software.amazon.awssdk.services.dynamodb.model.UpdateTimeToLiveRequest;
import software.amazon.awssdk.services.dynamodb.model.UpdateTimeToLiveResponse;
import software.amazon.awssdk.services.dynamodb.paginators.BatchGetItemPublisher;
import software.amazon.awssdk.services.dynamodb.paginators.ListTablesPublisher;
import software.amazon.awssdk.services.dynamodb.paginators.QueryPublisher;
import software.amazon.awssdk.services.dynamodb.paginators.ScanPublisher;
/**
* Service client for accessing DynamoDB asynchronously. This can be created using the static {@link #builder()} method.
*
* Amazon DynamoDB
*
* Amazon DynamoDB is a fully managed NoSQL database service that provides fast and predictable performance with
* seamless scalability. DynamoDB lets you offload the administrative burdens of operating and scaling a distributed
* database, so that you don't have to worry about hardware provisioning, setup and configuration, replication, software
* patching, or cluster scaling.
*
*
* With DynamoDB, you can create database tables that can store and retrieve any amount of data, and serve any level of
* request traffic. You can scale up or scale down your tables' throughput capacity without downtime or performance
* degradation, and use the AWS Management Console to monitor resource utilization and performance metrics.
*
*
* DynamoDB automatically spreads the data and traffic for your tables over a sufficient number of servers to handle
* your throughput and storage requirements, while maintaining consistent and fast performance. All of your data is
* stored on solid state disks (SSDs) and automatically replicated across multiple Availability Zones in an AWS region,
* providing built-in high availability and data durability.
*
*/
@Generated("software.amazon.awssdk:codegen")
public interface DynamoDbAsyncClient extends SdkClient {
String SERVICE_NAME = "dynamodb";
/**
* Create a {@link DynamoDbAsyncClient} with the region loaded from the
* {@link software.amazon.awssdk.regions.providers.DefaultAwsRegionProviderChain} and credentials loaded from the
* {@link software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider}.
*/
static DynamoDbAsyncClient create() {
return builder().build();
}
/**
* Create a builder that can be used to configure and create a {@link DynamoDbAsyncClient}.
*/
static DynamoDbAsyncClientBuilder builder() {
return new DefaultDynamoDbAsyncClientBuilder();
}
/**
*
* The BatchGetItem operation returns the attributes of one or more items from one or more tables. You
* identify requested items by primary key.
*
*
* A single operation can retrieve up to 16 MB of data, which can contain as many as 100 items.
* BatchGetItem will return a partial result if the response size limit is exceeded, the table's
* provisioned throughput is exceeded, or an internal processing failure occurs. If a partial result is returned,
* the operation returns a value for UnprocessedKeys. You can use this value to retry the operation
* starting with the next item to get.
*
*
*
* If you request more than 100 items BatchGetItem will return a ValidationException with
* the message "Too many items requested for the BatchGetItem call".
*
*
*
* For example, if you ask to retrieve 100 items, but each individual item is 300 KB in size, the system returns 52
* items (so as not to exceed the 16 MB limit). It also returns an appropriate UnprocessedKeys value so
* you can get the next page of results. If desired, your application can include its own logic to assemble the
* pages of results into one data set.
*
*
* If none of the items can be processed due to insufficient provisioned throughput on all of the tables in
* the request, then BatchGetItem will return a ProvisionedThroughputExceededException. If
* at least one of the items is successfully processed, then BatchGetItem completes
* successfully, while returning the keys of the unread items in UnprocessedKeys.
*
*
*
* If DynamoDB returns any unprocessed items, you should retry the batch operation on those items. However, we
* strongly recommend that you use an exponential backoff algorithm. If you retry the batch operation
* immediately, the underlying read or write requests can still fail due to throttling on the individual tables. If
* you delay the batch operation using exponential backoff, the individual requests in the batch are much more
* likely to succeed.
*
*
* For more information, see Batch
* Operations and Error Handling in the Amazon DynamoDB Developer Guide.
*
*
*
* By default, BatchGetItem performs eventually consistent reads on every table in the request. If you
* want strongly consistent reads instead, you can set ConsistentRead to true for any or
* all tables.
*
*
* In order to minimize response latency, BatchGetItem retrieves items in parallel.
*
*
* When designing your application, keep in mind that DynamoDB does not return items in any particular order. To
* help parse the response by item, include the primary key values for the items in your request in the
* ProjectionExpression parameter.
*
*
* If a requested item does not exist, it is not returned in the result. Requests for nonexistent items consume the
* minimum read capacity units according to the type of read. For more information, see Capacity Units Calculations in the Amazon DynamoDB Developer Guide.
*
*
* @param batchGetItemRequest
* Represents the input of a BatchGetItem operation.
* @return A Java Future containing the result of the BatchGetItem operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ProvisionedThroughputExceededException Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your request is eventually successful, unless
* your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff.
* For more information, go to Error Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.BatchGetItem
* @see AWS API
* Documentation
*/
default CompletableFuture batchGetItem(BatchGetItemRequest batchGetItemRequest) {
throw new UnsupportedOperationException();
}
/**
*
* The BatchGetItem operation returns the attributes of one or more items from one or more tables. You
* identify requested items by primary key.
*
*
* A single operation can retrieve up to 16 MB of data, which can contain as many as 100 items.
* BatchGetItem will return a partial result if the response size limit is exceeded, the table's
* provisioned throughput is exceeded, or an internal processing failure occurs. If a partial result is returned,
* the operation returns a value for UnprocessedKeys. You can use this value to retry the operation
* starting with the next item to get.
*
*
*
* If you request more than 100 items BatchGetItem will return a ValidationException with
* the message "Too many items requested for the BatchGetItem call".
*
*
*
* For example, if you ask to retrieve 100 items, but each individual item is 300 KB in size, the system returns 52
* items (so as not to exceed the 16 MB limit). It also returns an appropriate UnprocessedKeys value so
* you can get the next page of results. If desired, your application can include its own logic to assemble the
* pages of results into one data set.
*
*
* If none of the items can be processed due to insufficient provisioned throughput on all of the tables in
* the request, then BatchGetItem will return a ProvisionedThroughputExceededException. If
* at least one of the items is successfully processed, then BatchGetItem completes
* successfully, while returning the keys of the unread items in UnprocessedKeys.
*
*
*
* If DynamoDB returns any unprocessed items, you should retry the batch operation on those items. However, we
* strongly recommend that you use an exponential backoff algorithm. If you retry the batch operation
* immediately, the underlying read or write requests can still fail due to throttling on the individual tables. If
* you delay the batch operation using exponential backoff, the individual requests in the batch are much more
* likely to succeed.
*
*
* For more information, see Batch
* Operations and Error Handling in the Amazon DynamoDB Developer Guide.
*
*
*
* By default, BatchGetItem performs eventually consistent reads on every table in the request. If you
* want strongly consistent reads instead, you can set ConsistentRead to true for any or
* all tables.
*
*
* In order to minimize response latency, BatchGetItem retrieves items in parallel.
*
*
* When designing your application, keep in mind that DynamoDB does not return items in any particular order. To
* help parse the response by item, include the primary key values for the items in your request in the
* ProjectionExpression parameter.
*
*
* If a requested item does not exist, it is not returned in the result. Requests for nonexistent items consume the
* minimum read capacity units according to the type of read. For more information, see Capacity Units Calculations in the Amazon DynamoDB Developer Guide.
*
*
*
* This is a convenience which creates an instance of the {@link BatchGetItemRequest.Builder} avoiding the need to
* create one manually via {@link BatchGetItemRequest#builder()}
*
*
* @param batchGetItemRequest
* A {@link Consumer} that will call methods on {@link BatchGetItemInput.Builder} to create a request.
* Represents the input of a BatchGetItem operation.
* @return A Java Future containing the result of the BatchGetItem operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ProvisionedThroughputExceededException Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your request is eventually successful, unless
* your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff.
* For more information, go to Error Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.BatchGetItem
* @see AWS API
* Documentation
*/
default CompletableFuture batchGetItem(Consumer batchGetItemRequest) {
return batchGetItem(BatchGetItemRequest.builder().applyMutation(batchGetItemRequest).build());
}
/**
*
* The BatchGetItem operation returns the attributes of one or more items from one or more tables. You
* identify requested items by primary key.
*
*
* A single operation can retrieve up to 16 MB of data, which can contain as many as 100 items.
* BatchGetItem will return a partial result if the response size limit is exceeded, the table's
* provisioned throughput is exceeded, or an internal processing failure occurs. If a partial result is returned,
* the operation returns a value for UnprocessedKeys. You can use this value to retry the operation
* starting with the next item to get.
*
*
*
* If you request more than 100 items BatchGetItem will return a ValidationException with
* the message "Too many items requested for the BatchGetItem call".
*
*
*
* For example, if you ask to retrieve 100 items, but each individual item is 300 KB in size, the system returns 52
* items (so as not to exceed the 16 MB limit). It also returns an appropriate UnprocessedKeys value so
* you can get the next page of results. If desired, your application can include its own logic to assemble the
* pages of results into one data set.
*
*
* If none of the items can be processed due to insufficient provisioned throughput on all of the tables in
* the request, then BatchGetItem will return a ProvisionedThroughputExceededException. If
* at least one of the items is successfully processed, then BatchGetItem completes
* successfully, while returning the keys of the unread items in UnprocessedKeys.
*
*
*
* If DynamoDB returns any unprocessed items, you should retry the batch operation on those items. However, we
* strongly recommend that you use an exponential backoff algorithm. If you retry the batch operation
* immediately, the underlying read or write requests can still fail due to throttling on the individual tables. If
* you delay the batch operation using exponential backoff, the individual requests in the batch are much more
* likely to succeed.
*
*
* For more information, see Batch
* Operations and Error Handling in the Amazon DynamoDB Developer Guide.
*
*
*
* By default, BatchGetItem performs eventually consistent reads on every table in the request. If you
* want strongly consistent reads instead, you can set ConsistentRead to true for any or
* all tables.
*
*
* In order to minimize response latency, BatchGetItem retrieves items in parallel.
*
*
* When designing your application, keep in mind that DynamoDB does not return items in any particular order. To
* help parse the response by item, include the primary key values for the items in your request in the
* ProjectionExpression parameter.
*
*
* If a requested item does not exist, it is not returned in the result. Requests for nonexistent items consume the
* minimum read capacity units according to the type of read. For more information, see Capacity Units Calculations in the Amazon DynamoDB Developer Guide.
*
*
*
* This is a variant of {@link #batchGetItem(software.amazon.awssdk.services.dynamodb.model.BatchGetItemRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the forEach helper method
*
*
* {@code
* software.amazon.awssdk.services.dynamodb.paginators.BatchGetItemPublisher publisher = client.batchGetItemPaginator(request);
* CompletableFuture future = publisher.forEach(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.dynamodb.paginators.BatchGetItemPublisher publisher = client.batchGetItemPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.dynamodb.model.BatchGetItemResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Note: If you prefer to have control on service calls, use the
* {@link #batchGetItem(software.amazon.awssdk.services.dynamodb.model.BatchGetItemRequest)} operation.
*
*
* @param batchGetItemRequest
* Represents the input of a BatchGetItem operation.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ProvisionedThroughputExceededException Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your request is eventually successful, unless
* your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff.
* For more information, go to Error Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.BatchGetItem
* @see AWS API
* Documentation
*/
default BatchGetItemPublisher batchGetItemPaginator(BatchGetItemRequest batchGetItemRequest) {
throw new UnsupportedOperationException();
}
/**
*
* The BatchGetItem operation returns the attributes of one or more items from one or more tables. You
* identify requested items by primary key.
*
*
* A single operation can retrieve up to 16 MB of data, which can contain as many as 100 items.
* BatchGetItem will return a partial result if the response size limit is exceeded, the table's
* provisioned throughput is exceeded, or an internal processing failure occurs. If a partial result is returned,
* the operation returns a value for UnprocessedKeys. You can use this value to retry the operation
* starting with the next item to get.
*
*
*
* If you request more than 100 items BatchGetItem will return a ValidationException with
* the message "Too many items requested for the BatchGetItem call".
*
*
*
* For example, if you ask to retrieve 100 items, but each individual item is 300 KB in size, the system returns 52
* items (so as not to exceed the 16 MB limit). It also returns an appropriate UnprocessedKeys value so
* you can get the next page of results. If desired, your application can include its own logic to assemble the
* pages of results into one data set.
*
*
* If none of the items can be processed due to insufficient provisioned throughput on all of the tables in
* the request, then BatchGetItem will return a ProvisionedThroughputExceededException. If
* at least one of the items is successfully processed, then BatchGetItem completes
* successfully, while returning the keys of the unread items in UnprocessedKeys.
*
*
*
* If DynamoDB returns any unprocessed items, you should retry the batch operation on those items. However, we
* strongly recommend that you use an exponential backoff algorithm. If you retry the batch operation
* immediately, the underlying read or write requests can still fail due to throttling on the individual tables. If
* you delay the batch operation using exponential backoff, the individual requests in the batch are much more
* likely to succeed.
*
*
* For more information, see Batch
* Operations and Error Handling in the Amazon DynamoDB Developer Guide.
*
*
*
* By default, BatchGetItem performs eventually consistent reads on every table in the request. If you
* want strongly consistent reads instead, you can set ConsistentRead to true for any or
* all tables.
*
*
* In order to minimize response latency, BatchGetItem retrieves items in parallel.
*
*
* When designing your application, keep in mind that DynamoDB does not return items in any particular order. To
* help parse the response by item, include the primary key values for the items in your request in the
* ProjectionExpression parameter.
*
*
* If a requested item does not exist, it is not returned in the result. Requests for nonexistent items consume the
* minimum read capacity units according to the type of read. For more information, see Capacity Units Calculations in the Amazon DynamoDB Developer Guide.
*
*
*
* This is a variant of {@link #batchGetItem(software.amazon.awssdk.services.dynamodb.model.BatchGetItemRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the forEach helper method
*
*
* {@code
* software.amazon.awssdk.services.dynamodb.paginators.BatchGetItemPublisher publisher = client.batchGetItemPaginator(request);
* CompletableFuture future = publisher.forEach(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.dynamodb.paginators.BatchGetItemPublisher publisher = client.batchGetItemPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.dynamodb.model.BatchGetItemResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Note: If you prefer to have control on service calls, use the
* {@link #batchGetItem(software.amazon.awssdk.services.dynamodb.model.BatchGetItemRequest)} operation.
*
*
* This is a convenience which creates an instance of the {@link BatchGetItemRequest.Builder} avoiding the need to
* create one manually via {@link BatchGetItemRequest#builder()}
*
*
* @param batchGetItemRequest
* A {@link Consumer} that will call methods on {@link BatchGetItemInput.Builder} to create a request.
* Represents the input of a BatchGetItem operation.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ProvisionedThroughputExceededException Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your request is eventually successful, unless
* your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff.
* For more information, go to Error Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.BatchGetItem
* @see AWS API
* Documentation
*/
default BatchGetItemPublisher batchGetItemPaginator(Consumer batchGetItemRequest) {
return batchGetItemPaginator(BatchGetItemRequest.builder().applyMutation(batchGetItemRequest).build());
}
/**
*
* The BatchWriteItem operation puts or deletes multiple items in one or more tables. A single call to
* BatchWriteItem can write up to 16 MB of data, which can comprise as many as 25 put or delete
* requests. Individual items to be written can be as large as 400 KB.
*
*
*
* BatchWriteItem cannot update items. To update items, use the UpdateItem action.
*
*
*
* The individual PutItem and DeleteItem operations specified in
* BatchWriteItem are atomic; however BatchWriteItem as a whole is not. If any requested
* operations fail because the table's provisioned throughput is exceeded or an internal processing failure occurs,
* the failed operations are returned in the UnprocessedItems response parameter. You can investigate
* and optionally resend the requests. Typically, you would call BatchWriteItem in a loop. Each
* iteration would check for unprocessed items and submit a new BatchWriteItem request with those
* unprocessed items until all items have been processed.
*
*
* Note that if none of the items can be processed due to insufficient provisioned throughput on all of the
* tables in the request, then BatchWriteItem will return a
* ProvisionedThroughputExceededException.
*
*
*
* If DynamoDB returns any unprocessed items, you should retry the batch operation on those items. However, we
* strongly recommend that you use an exponential backoff algorithm. If you retry the batch operation
* immediately, the underlying read or write requests can still fail due to throttling on the individual tables. If
* you delay the batch operation using exponential backoff, the individual requests in the batch are much more
* likely to succeed.
*
*
* For more information, see Batch
* Operations and Error Handling in the Amazon DynamoDB Developer Guide.
*
*
*
* With BatchWriteItem, you can efficiently write or delete large amounts of data, such as from Amazon
* Elastic MapReduce (EMR), or copy data from another database into DynamoDB. In order to improve performance with
* these large-scale operations, BatchWriteItem does not behave in the same way as individual
* PutItem and DeleteItem calls would. For example, you cannot specify conditions on
* individual put and delete requests, and BatchWriteItem does not return deleted items in the
* response.
*
*
* If you use a programming language that supports concurrency, you can use threads to write items in parallel. Your
* application must include the necessary logic to manage the threads. With languages that don't support threading,
* you must update or delete the specified items one at a time. In both situations, BatchWriteItem
* performs the specified put and delete operations in parallel, giving you the power of the thread pool approach
* without having to introduce complexity into your application.
*
*
* Parallel processing reduces latency, but each specified put and delete request consumes the same number of write
* capacity units whether it is processed in parallel or not. Delete operations on nonexistent items consume one
* write capacity unit.
*
*
* If one or more of the following is true, DynamoDB rejects the entire batch write operation:
*
*
* -
*
* One or more tables specified in the BatchWriteItem request does not exist.
*
*
* -
*
* Primary key attributes specified on an item in the request do not match those in the corresponding table's
* primary key schema.
*
*
* -
*
* You try to perform multiple operations on the same item in the same BatchWriteItem request. For
* example, you cannot put and delete the same item in the same BatchWriteItem request.
*
*
* -
*
* Your request contains at least two items with identical hash and range keys (which essentially is two put
* operations).
*
*
* -
*
* There are more than 25 requests in the batch.
*
*
* -
*
* Any individual item in a batch exceeds 400 KB.
*
*
* -
*
* The total request size exceeds 16 MB.
*
*
*
*
* @param batchWriteItemRequest
* Represents the input of a BatchWriteItem operation.
* @return A Java Future containing the result of the BatchWriteItem operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ProvisionedThroughputExceededException Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your request is eventually successful, unless
* your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff.
* For more information, go to Error Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - ItemCollectionSizeLimitExceededException An item collection is too large. This exception is only
* returned for tables that have one or more local secondary indexes.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.BatchWriteItem
* @see AWS API
* Documentation
*/
default CompletableFuture batchWriteItem(BatchWriteItemRequest batchWriteItemRequest) {
throw new UnsupportedOperationException();
}
/**
*
* The BatchWriteItem operation puts or deletes multiple items in one or more tables. A single call to
* BatchWriteItem can write up to 16 MB of data, which can comprise as many as 25 put or delete
* requests. Individual items to be written can be as large as 400 KB.
*
*
*
* BatchWriteItem cannot update items. To update items, use the UpdateItem action.
*
*
*
* The individual PutItem and DeleteItem operations specified in
* BatchWriteItem are atomic; however BatchWriteItem as a whole is not. If any requested
* operations fail because the table's provisioned throughput is exceeded or an internal processing failure occurs,
* the failed operations are returned in the UnprocessedItems response parameter. You can investigate
* and optionally resend the requests. Typically, you would call BatchWriteItem in a loop. Each
* iteration would check for unprocessed items and submit a new BatchWriteItem request with those
* unprocessed items until all items have been processed.
*
*
* Note that if none of the items can be processed due to insufficient provisioned throughput on all of the
* tables in the request, then BatchWriteItem will return a
* ProvisionedThroughputExceededException.
*
*
*
* If DynamoDB returns any unprocessed items, you should retry the batch operation on those items. However, we
* strongly recommend that you use an exponential backoff algorithm. If you retry the batch operation
* immediately, the underlying read or write requests can still fail due to throttling on the individual tables. If
* you delay the batch operation using exponential backoff, the individual requests in the batch are much more
* likely to succeed.
*
*
* For more information, see Batch
* Operations and Error Handling in the Amazon DynamoDB Developer Guide.
*
*
*
* With BatchWriteItem, you can efficiently write or delete large amounts of data, such as from Amazon
* Elastic MapReduce (EMR), or copy data from another database into DynamoDB. In order to improve performance with
* these large-scale operations, BatchWriteItem does not behave in the same way as individual
* PutItem and DeleteItem calls would. For example, you cannot specify conditions on
* individual put and delete requests, and BatchWriteItem does not return deleted items in the
* response.
*
*
* If you use a programming language that supports concurrency, you can use threads to write items in parallel. Your
* application must include the necessary logic to manage the threads. With languages that don't support threading,
* you must update or delete the specified items one at a time. In both situations, BatchWriteItem
* performs the specified put and delete operations in parallel, giving you the power of the thread pool approach
* without having to introduce complexity into your application.
*
*
* Parallel processing reduces latency, but each specified put and delete request consumes the same number of write
* capacity units whether it is processed in parallel or not. Delete operations on nonexistent items consume one
* write capacity unit.
*
*
* If one or more of the following is true, DynamoDB rejects the entire batch write operation:
*
*
* -
*
* One or more tables specified in the BatchWriteItem request does not exist.
*
*
* -
*
* Primary key attributes specified on an item in the request do not match those in the corresponding table's
* primary key schema.
*
*
* -
*
* You try to perform multiple operations on the same item in the same BatchWriteItem request. For
* example, you cannot put and delete the same item in the same BatchWriteItem request.
*
*
* -
*
* Your request contains at least two items with identical hash and range keys (which essentially is two put
* operations).
*
*
* -
*
* There are more than 25 requests in the batch.
*
*
* -
*
* Any individual item in a batch exceeds 400 KB.
*
*
* -
*
* The total request size exceeds 16 MB.
*
*
*
*
*
* This is a convenience which creates an instance of the {@link BatchWriteItemRequest.Builder} avoiding the need to
* create one manually via {@link BatchWriteItemRequest#builder()}
*
*
* @param batchWriteItemRequest
* A {@link Consumer} that will call methods on {@link BatchWriteItemInput.Builder} to create a request.
* Represents the input of a BatchWriteItem operation.
* @return A Java Future containing the result of the BatchWriteItem operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ProvisionedThroughputExceededException Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your request is eventually successful, unless
* your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff.
* For more information, go to Error Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - ItemCollectionSizeLimitExceededException An item collection is too large. This exception is only
* returned for tables that have one or more local secondary indexes.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.BatchWriteItem
* @see AWS API
* Documentation
*/
default CompletableFuture batchWriteItem(Consumer batchWriteItemRequest) {
return batchWriteItem(BatchWriteItemRequest.builder().applyMutation(batchWriteItemRequest).build());
}
/**
*
* Creates a backup for an existing table.
*
*
* Each time you create an On-Demand Backup, the entire table data is backed up. There is no limit to the number of
* on-demand backups that can be taken.
*
*
* When you create an On-Demand Backup, a time marker of the request is cataloged, and the backup is created
* asynchronously, by applying all changes until the time of the request to the last full table snapshot. Backup
* requests are processed instantaneously and become available for restore within minutes.
*
*
* You can call CreateBackup at a maximum rate of 50 times per second.
*
*
* All backups in DynamoDB work without consuming any provisioned throughput on the table.
*
*
* If you submit a backup request on 2018-12-14 at 14:25:00, the backup is guaranteed to contain all data committed
* to the table up to 14:24:00, and data committed after 14:26:00 will not be. The backup may or may not contain
* data modifications made between 14:24:00 and 14:26:00. On-Demand Backup does not support causal consistency.
*
*
* Along with data, the following are also included on the backups:
*
*
* -
*
* Global secondary indexes (GSIs)
*
*
* -
*
* Local secondary indexes (LSIs)
*
*
* -
*
* Streams
*
*
* -
*
* Provisioned read and write capacity
*
*
*
*
* @param createBackupRequest
* @return A Java Future containing the result of the CreateBackup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - TableNotFoundException A source table with the name
TableName does not currently exist
* within the subscriber's account.
* - TableInUseException A target table with the specified name is either being created or deleted.
* - ContinuousBackupsUnavailableException Backups have not yet been enabled for this table.
* - BackupInUseException There is another ongoing conflicting backup control plane operation on the
* table. The backups is either being created, deleted or restored to a table.
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.CreateBackup
* @see AWS API
* Documentation
*/
default CompletableFuture createBackup(CreateBackupRequest createBackupRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates a backup for an existing table.
*
*
* Each time you create an On-Demand Backup, the entire table data is backed up. There is no limit to the number of
* on-demand backups that can be taken.
*
*
* When you create an On-Demand Backup, a time marker of the request is cataloged, and the backup is created
* asynchronously, by applying all changes until the time of the request to the last full table snapshot. Backup
* requests are processed instantaneously and become available for restore within minutes.
*
*
* You can call CreateBackup at a maximum rate of 50 times per second.
*
*
* All backups in DynamoDB work without consuming any provisioned throughput on the table.
*
*
* If you submit a backup request on 2018-12-14 at 14:25:00, the backup is guaranteed to contain all data committed
* to the table up to 14:24:00, and data committed after 14:26:00 will not be. The backup may or may not contain
* data modifications made between 14:24:00 and 14:26:00. On-Demand Backup does not support causal consistency.
*
*
* Along with data, the following are also included on the backups:
*
*
* -
*
* Global secondary indexes (GSIs)
*
*
* -
*
* Local secondary indexes (LSIs)
*
*
* -
*
* Streams
*
*
* -
*
* Provisioned read and write capacity
*
*
*
*
*
* This is a convenience which creates an instance of the {@link CreateBackupRequest.Builder} avoiding the need to
* create one manually via {@link CreateBackupRequest#builder()}
*
*
* @param createBackupRequest
* A {@link Consumer} that will call methods on {@link CreateBackupInput.Builder} to create a request.
* @return A Java Future containing the result of the CreateBackup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - TableNotFoundException A source table with the name
TableName does not currently exist
* within the subscriber's account.
* - TableInUseException A target table with the specified name is either being created or deleted.
* - ContinuousBackupsUnavailableException Backups have not yet been enabled for this table.
* - BackupInUseException There is another ongoing conflicting backup control plane operation on the
* table. The backups is either being created, deleted or restored to a table.
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.CreateBackup
* @see AWS API
* Documentation
*/
default CompletableFuture createBackup(Consumer createBackupRequest) {
return createBackup(CreateBackupRequest.builder().applyMutation(createBackupRequest).build());
}
/**
*
* Creates a global table from an existing table. A global table creates a replication relationship between two or
* more DynamoDB tables with the same table name in the provided regions.
*
*
* Tables can only be added as the replicas of a global table group under the following conditions:
*
*
* -
*
* The tables must have the same name.
*
*
* -
*
* The tables must contain no items.
*
*
* -
*
* The tables must have the same hash key and sort key (if present).
*
*
* -
*
* The tables must have DynamoDB Streams enabled (NEW_AND_OLD_IMAGES).
*
*
* -
*
* The tables must have same provisioned and maximum write capacity units.
*
*
*
*
* If global secondary indexes are specified, then the following conditions must also be met:
*
*
* -
*
* The global secondary indexes must have the same name.
*
*
* -
*
* The global secondary indexes must have the same hash key and sort key (if present).
*
*
* -
*
* The global secondary indexes must have the same provisioned and maximum write capacity units.
*
*
*
*
* @param createGlobalTableRequest
* @return A Java Future containing the result of the CreateGlobalTable operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - InternalServerErrorException An error occurred on the server side.
* - GlobalTableAlreadyExistsException The specified global table already exists.
* - TableNotFoundException A source table with the name
TableName does not currently exist
* within the subscriber's account.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.CreateGlobalTable
* @see AWS API
* Documentation
*/
default CompletableFuture createGlobalTable(CreateGlobalTableRequest createGlobalTableRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates a global table from an existing table. A global table creates a replication relationship between two or
* more DynamoDB tables with the same table name in the provided regions.
*
*
* Tables can only be added as the replicas of a global table group under the following conditions:
*
*
* -
*
* The tables must have the same name.
*
*
* -
*
* The tables must contain no items.
*
*
* -
*
* The tables must have the same hash key and sort key (if present).
*
*
* -
*
* The tables must have DynamoDB Streams enabled (NEW_AND_OLD_IMAGES).
*
*
* -
*
* The tables must have same provisioned and maximum write capacity units.
*
*
*
*
* If global secondary indexes are specified, then the following conditions must also be met:
*
*
* -
*
* The global secondary indexes must have the same name.
*
*
* -
*
* The global secondary indexes must have the same hash key and sort key (if present).
*
*
* -
*
* The global secondary indexes must have the same provisioned and maximum write capacity units.
*
*
*
*
*
* This is a convenience which creates an instance of the {@link CreateGlobalTableRequest.Builder} avoiding the need
* to create one manually via {@link CreateGlobalTableRequest#builder()}
*
*
* @param createGlobalTableRequest
* A {@link Consumer} that will call methods on {@link CreateGlobalTableInput.Builder} to create a request.
* @return A Java Future containing the result of the CreateGlobalTable operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - InternalServerErrorException An error occurred on the server side.
* - GlobalTableAlreadyExistsException The specified global table already exists.
* - TableNotFoundException A source table with the name
TableName does not currently exist
* within the subscriber's account.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.CreateGlobalTable
* @see AWS API
* Documentation
*/
default CompletableFuture createGlobalTable(
Consumer createGlobalTableRequest) {
return createGlobalTable(CreateGlobalTableRequest.builder().applyMutation(createGlobalTableRequest).build());
}
/**
*
* The CreateTable operation adds a new table to your account. In an AWS account, table names must be
* unique within each region. That is, you can have two tables with same name if you create the tables in different
* regions.
*
*
* CreateTable is an asynchronous operation. Upon receiving a CreateTable request,
* DynamoDB immediately returns a response with a TableStatus of CREATING. After the table
* is created, DynamoDB sets the TableStatus to ACTIVE. You can perform read and write
* operations only on an ACTIVE table.
*
*
* You can optionally define secondary indexes on the new table, as part of the CreateTable operation.
* If you want to create multiple tables with secondary indexes on them, you must create the tables sequentially.
* Only one table with secondary indexes can be in the CREATING state at any given time.
*
*
* You can use the DescribeTable action to check the table status.
*
*
* @param createTableRequest
* Represents the input of a CreateTable operation.
* @return A Java Future containing the result of the CreateTable operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ResourceInUseException The operation conflicts with the resource's availability. For example, you
* attempted to recreate an existing table, or tried to delete a table currently in the
*
CREATING state.
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.CreateTable
* @see AWS API
* Documentation
*/
default CompletableFuture createTable(CreateTableRequest createTableRequest) {
throw new UnsupportedOperationException();
}
/**
*
* The CreateTable operation adds a new table to your account. In an AWS account, table names must be
* unique within each region. That is, you can have two tables with same name if you create the tables in different
* regions.
*
*
* CreateTable is an asynchronous operation. Upon receiving a CreateTable request,
* DynamoDB immediately returns a response with a TableStatus of CREATING. After the table
* is created, DynamoDB sets the TableStatus to ACTIVE. You can perform read and write
* operations only on an ACTIVE table.
*
*
* You can optionally define secondary indexes on the new table, as part of the CreateTable operation.
* If you want to create multiple tables with secondary indexes on them, you must create the tables sequentially.
* Only one table with secondary indexes can be in the CREATING state at any given time.
*
*
* You can use the DescribeTable action to check the table status.
*
*
*
* This is a convenience which creates an instance of the {@link CreateTableRequest.Builder} avoiding the need to
* create one manually via {@link CreateTableRequest#builder()}
*
*
* @param createTableRequest
* A {@link Consumer} that will call methods on {@link CreateTableInput.Builder} to create a request.
* Represents the input of a CreateTable operation.
* @return A Java Future containing the result of the CreateTable operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ResourceInUseException The operation conflicts with the resource's availability. For example, you
* attempted to recreate an existing table, or tried to delete a table currently in the
*
CREATING state.
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.CreateTable
* @see AWS API
* Documentation
*/
default CompletableFuture createTable(Consumer createTableRequest) {
return createTable(CreateTableRequest.builder().applyMutation(createTableRequest).build());
}
/**
*
* Deletes an existing backup of a table.
*
*
* You can call DeleteBackup at a maximum rate of 10 times per second.
*
*
* @param deleteBackupRequest
* @return A Java Future containing the result of the DeleteBackup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - BackupNotFoundException Backup not found for the given BackupARN.
* - BackupInUseException There is another ongoing conflicting backup control plane operation on the
* table. The backups is either being created, deleted or restored to a table.
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.DeleteBackup
* @see AWS API
* Documentation
*/
default CompletableFuture deleteBackup(DeleteBackupRequest deleteBackupRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Deletes an existing backup of a table.
*
*
* You can call DeleteBackup at a maximum rate of 10 times per second.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteBackupRequest.Builder} avoiding the need to
* create one manually via {@link DeleteBackupRequest#builder()}
*
*
* @param deleteBackupRequest
* A {@link Consumer} that will call methods on {@link DeleteBackupInput.Builder} to create a request.
* @return A Java Future containing the result of the DeleteBackup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - BackupNotFoundException Backup not found for the given BackupARN.
* - BackupInUseException There is another ongoing conflicting backup control plane operation on the
* table. The backups is either being created, deleted or restored to a table.
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.DeleteBackup
* @see AWS API
* Documentation
*/
default CompletableFuture deleteBackup(Consumer deleteBackupRequest) {
return deleteBackup(DeleteBackupRequest.builder().applyMutation(deleteBackupRequest).build());
}
/**
*
* Deletes a single item in a table by primary key. You can perform a conditional delete operation that deletes the
* item if it exists, or if it has an expected attribute value.
*
*
* In addition to deleting an item, you can also return the item's attribute values in the same operation, using the
* ReturnValues parameter.
*
*
* Unless you specify conditions, the DeleteItem is an idempotent operation; running it multiple times
* on the same item or attribute does not result in an error response.
*
*
* Conditional deletes are useful for deleting items only if specific conditions are met. If those conditions are
* met, DynamoDB performs the delete. Otherwise, the item is not deleted.
*
*
* @param deleteItemRequest
* Represents the input of a DeleteItem operation.
* @return A Java Future containing the result of the DeleteItem operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ConditionalCheckFailedException A condition specified in the operation could not be evaluated.
* - ProvisionedThroughputExceededException Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your request is eventually successful, unless
* your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff.
* For more information, go to Error Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - ItemCollectionSizeLimitExceededException An item collection is too large. This exception is only
* returned for tables that have one or more local secondary indexes.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.DeleteItem
* @see AWS API
* Documentation
*/
default CompletableFuture deleteItem(DeleteItemRequest deleteItemRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Deletes a single item in a table by primary key. You can perform a conditional delete operation that deletes the
* item if it exists, or if it has an expected attribute value.
*
*
* In addition to deleting an item, you can also return the item's attribute values in the same operation, using the
* ReturnValues parameter.
*
*
* Unless you specify conditions, the DeleteItem is an idempotent operation; running it multiple times
* on the same item or attribute does not result in an error response.
*
*
* Conditional deletes are useful for deleting items only if specific conditions are met. If those conditions are
* met, DynamoDB performs the delete. Otherwise, the item is not deleted.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteItemRequest.Builder} avoiding the need to
* create one manually via {@link DeleteItemRequest#builder()}
*
*
* @param deleteItemRequest
* A {@link Consumer} that will call methods on {@link DeleteItemInput.Builder} to create a request.
* Represents the input of a DeleteItem operation.
* @return A Java Future containing the result of the DeleteItem operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ConditionalCheckFailedException A condition specified in the operation could not be evaluated.
* - ProvisionedThroughputExceededException Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your request is eventually successful, unless
* your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff.
* For more information, go to Error Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - ItemCollectionSizeLimitExceededException An item collection is too large. This exception is only
* returned for tables that have one or more local secondary indexes.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.DeleteItem
* @see AWS API
* Documentation
*/
default CompletableFuture deleteItem(Consumer deleteItemRequest) {
return deleteItem(DeleteItemRequest.builder().applyMutation(deleteItemRequest).build());
}
/**
*
* The DeleteTable operation deletes a table and all of its items. After a DeleteTable
* request, the specified table is in the DELETING state until DynamoDB completes the deletion. If the
* table is in the ACTIVE state, you can delete it. If a table is in CREATING or
* UPDATING states, then DynamoDB returns a ResourceInUseException. If the specified table
* does not exist, DynamoDB returns a ResourceNotFoundException. If table is already in the
* DELETING state, no error is returned.
*
*
*
* DynamoDB might continue to accept data read and write operations, such as GetItem and
* PutItem, on a table in the DELETING state until the table deletion is complete.
*
*
*
* When you delete a table, any indexes on that table are also deleted.
*
*
* If you have DynamoDB Streams enabled on the table, then the corresponding stream on that table goes into the
* DISABLED state, and the stream is automatically deleted after 24 hours.
*
*
* Use the DescribeTable action to check the status of the table.
*
*
* @param deleteTableRequest
* Represents the input of a DeleteTable operation.
* @return A Java Future containing the result of the DeleteTable operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ResourceInUseException The operation conflicts with the resource's availability. For example, you
* attempted to recreate an existing table, or tried to delete a table currently in the
*
CREATING state.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.DeleteTable
* @see AWS API
* Documentation
*/
default CompletableFuture deleteTable(DeleteTableRequest deleteTableRequest) {
throw new UnsupportedOperationException();
}
/**
*
* The DeleteTable operation deletes a table and all of its items. After a DeleteTable
* request, the specified table is in the DELETING state until DynamoDB completes the deletion. If the
* table is in the ACTIVE state, you can delete it. If a table is in CREATING or
* UPDATING states, then DynamoDB returns a ResourceInUseException. If the specified table
* does not exist, DynamoDB returns a ResourceNotFoundException. If table is already in the
* DELETING state, no error is returned.
*
*
*
* DynamoDB might continue to accept data read and write operations, such as GetItem and
* PutItem, on a table in the DELETING state until the table deletion is complete.
*
*
*
* When you delete a table, any indexes on that table are also deleted.
*
*
* If you have DynamoDB Streams enabled on the table, then the corresponding stream on that table goes into the
* DISABLED state, and the stream is automatically deleted after 24 hours.
*
*
* Use the DescribeTable action to check the status of the table.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteTableRequest.Builder} avoiding the need to
* create one manually via {@link DeleteTableRequest#builder()}
*
*
* @param deleteTableRequest
* A {@link Consumer} that will call methods on {@link DeleteTableInput.Builder} to create a request.
* Represents the input of a DeleteTable operation.
* @return A Java Future containing the result of the DeleteTable operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ResourceInUseException The operation conflicts with the resource's availability. For example, you
* attempted to recreate an existing table, or tried to delete a table currently in the
*
CREATING state.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.DeleteTable
* @see AWS API
* Documentation
*/
default CompletableFuture deleteTable(Consumer deleteTableRequest) {
return deleteTable(DeleteTableRequest.builder().applyMutation(deleteTableRequest).build());
}
/**
*
* Describes an existing backup of a table.
*
*
* You can call DescribeBackup at a maximum rate of 10 times per second.
*
*
* @param describeBackupRequest
* @return A Java Future containing the result of the DescribeBackup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - BackupNotFoundException Backup not found for the given BackupARN.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.DescribeBackup
* @see AWS API
* Documentation
*/
default CompletableFuture describeBackup(DescribeBackupRequest describeBackupRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Describes an existing backup of a table.
*
*
* You can call DescribeBackup at a maximum rate of 10 times per second.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeBackupRequest.Builder} avoiding the need to
* create one manually via {@link DescribeBackupRequest#builder()}
*
*
* @param describeBackupRequest
* A {@link Consumer} that will call methods on {@link DescribeBackupInput.Builder} to create a request.
* @return A Java Future containing the result of the DescribeBackup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - BackupNotFoundException Backup not found for the given BackupARN.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.DescribeBackup
* @see AWS API
* Documentation
*/
default CompletableFuture describeBackup(Consumer describeBackupRequest) {
return describeBackup(DescribeBackupRequest.builder().applyMutation(describeBackupRequest).build());
}
/**
*
* Checks the status of continuous backups and point in time recovery on the specified table. Continuous backups are
* ENABLED on all tables at table creation. If point in time recovery is enabled,
* PointInTimeRecoveryStatus will be set to ENABLED.
*
*
* Once continuous backups and point in time recovery are enabled, you can restore to any point in time within
* EarliestRestorableDateTime and LatestRestorableDateTime.
*
*
* LatestRestorableDateTime is typically 5 minutes before the current time. You can restore your table
* to any point in time during the last 35 days.
*
*
* You can call DescribeContinuousBackups at a maximum rate of 10 times per second.
*
*
* @param describeContinuousBackupsRequest
* @return A Java Future containing the result of the DescribeContinuousBackups operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - TableNotFoundException A source table with the name
TableName does not currently exist
* within the subscriber's account.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.DescribeContinuousBackups
* @see AWS API Documentation
*/
default CompletableFuture describeContinuousBackups(
DescribeContinuousBackupsRequest describeContinuousBackupsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Checks the status of continuous backups and point in time recovery on the specified table. Continuous backups are
* ENABLED on all tables at table creation. If point in time recovery is enabled,
* PointInTimeRecoveryStatus will be set to ENABLED.
*
*
* Once continuous backups and point in time recovery are enabled, you can restore to any point in time within
* EarliestRestorableDateTime and LatestRestorableDateTime.
*
*
* LatestRestorableDateTime is typically 5 minutes before the current time. You can restore your table
* to any point in time during the last 35 days.
*
*
* You can call DescribeContinuousBackups at a maximum rate of 10 times per second.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeContinuousBackupsRequest.Builder} avoiding
* the need to create one manually via {@link DescribeContinuousBackupsRequest#builder()}
*
*
* @param describeContinuousBackupsRequest
* A {@link Consumer} that will call methods on {@link DescribeContinuousBackupsInput.Builder} to create a
* request.
* @return A Java Future containing the result of the DescribeContinuousBackups operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - TableNotFoundException A source table with the name
TableName does not currently exist
* within the subscriber's account.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.DescribeContinuousBackups
* @see AWS API Documentation
*/
default CompletableFuture describeContinuousBackups(
Consumer describeContinuousBackupsRequest) {
return describeContinuousBackups(DescribeContinuousBackupsRequest.builder()
.applyMutation(describeContinuousBackupsRequest).build());
}
/**
*
* Returns information about the specified global table.
*
*
* @param describeGlobalTableRequest
* @return A Java Future containing the result of the DescribeGlobalTable operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException An error occurred on the server side.
* - GlobalTableNotFoundException The specified global table does not exist.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.DescribeGlobalTable
* @see AWS
* API Documentation
*/
default CompletableFuture describeGlobalTable(
DescribeGlobalTableRequest describeGlobalTableRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns information about the specified global table.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeGlobalTableRequest.Builder} avoiding the
* need to create one manually via {@link DescribeGlobalTableRequest#builder()}
*
*
* @param describeGlobalTableRequest
* A {@link Consumer} that will call methods on {@link DescribeGlobalTableInput.Builder} to create a request.
* @return A Java Future containing the result of the DescribeGlobalTable operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException An error occurred on the server side.
* - GlobalTableNotFoundException The specified global table does not exist.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.DescribeGlobalTable
* @see AWS
* API Documentation
*/
default CompletableFuture describeGlobalTable(
Consumer describeGlobalTableRequest) {
return describeGlobalTable(DescribeGlobalTableRequest.builder().applyMutation(describeGlobalTableRequest).build());
}
/**
*
* Describes region specific settings for a global table.
*
*
* @param describeGlobalTableSettingsRequest
* @return A Java Future containing the result of the DescribeGlobalTableSettings operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - GlobalTableNotFoundException The specified global table does not exist.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.DescribeGlobalTableSettings
* @see AWS API Documentation
*/
default CompletableFuture describeGlobalTableSettings(
DescribeGlobalTableSettingsRequest describeGlobalTableSettingsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Describes region specific settings for a global table.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeGlobalTableSettingsRequest.Builder}
* avoiding the need to create one manually via {@link DescribeGlobalTableSettingsRequest#builder()}
*
*
* @param describeGlobalTableSettingsRequest
* A {@link Consumer} that will call methods on {@link DescribeGlobalTableSettingsInput.Builder} to create a
* request.
* @return A Java Future containing the result of the DescribeGlobalTableSettings operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - GlobalTableNotFoundException The specified global table does not exist.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.DescribeGlobalTableSettings
* @see AWS API Documentation
*/
default CompletableFuture describeGlobalTableSettings(
Consumer describeGlobalTableSettingsRequest) {
return describeGlobalTableSettings(DescribeGlobalTableSettingsRequest.builder()
.applyMutation(describeGlobalTableSettingsRequest).build());
}
/**
*
* Returns the current provisioned-capacity limits for your AWS account in a region, both for the region as a whole
* and for any one DynamoDB table that you create there.
*
*
* When you establish an AWS account, the account has initial limits on the maximum read capacity units and write
* capacity units that you can provision across all of your DynamoDB tables in a given region. Also, there are
* per-table limits that apply when you create a table there. For more information, see Limits page in the
* Amazon DynamoDB Developer Guide.
*
*
* Although you can increase these limits by filing a case at AWS Support Center, obtaining the increase is not
* instantaneous. The DescribeLimits action lets you write code to compare the capacity you are
* currently using to those limits imposed by your account so that you have enough time to apply for an increase
* before you hit a limit.
*
*
* For example, you could use one of the AWS SDKs to do the following:
*
*
* -
*
* Call DescribeLimits for a particular region to obtain your current account limits on provisioned
* capacity there.
*
*
* -
*
* Create a variable to hold the aggregate read capacity units provisioned for all your tables in that region, and
* one to hold the aggregate write capacity units. Zero them both.
*
*
* -
*
* Call ListTables to obtain a list of all your DynamoDB tables.
*
*
* -
*
* For each table name listed by ListTables, do the following:
*
*
* -
*
* Call DescribeTable with the table name.
*
*
* -
*
* Use the data returned by DescribeTable to add the read capacity units and write capacity units
* provisioned for the table itself to your variables.
*
*
* -
*
* If the table has one or more global secondary indexes (GSIs), loop over these GSIs and add their provisioned
* capacity values to your variables as well.
*
*
*
*
* -
*
* Report the account limits for that region returned by DescribeLimits, along with the total current
* provisioned capacity levels you have calculated.
*
*
*
*
* This will let you see whether you are getting close to your account-level limits.
*
*
* The per-table limits apply only when you are creating a new table. They restrict the sum of the provisioned
* capacity of the new table itself and all its global secondary indexes.
*
*
* For existing tables and their GSIs, DynamoDB will not let you increase provisioned capacity extremely rapidly,
* but the only upper limit that applies is that the aggregate provisioned capacity over all your tables and GSIs
* cannot exceed either of the per-account limits.
*
*
*
* DescribeLimits should only be called periodically. You can expect throttling errors if you call it
* more than once in a minute.
*
*
*
* The DescribeLimits Request element has no content.
*
*
* @param describeLimitsRequest
* Represents the input of a DescribeLimits operation. Has no content.
* @return A Java Future containing the result of the DescribeLimits operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.DescribeLimits
* @see AWS API
* Documentation
*/
default CompletableFuture describeLimits(DescribeLimitsRequest describeLimitsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns the current provisioned-capacity limits for your AWS account in a region, both for the region as a whole
* and for any one DynamoDB table that you create there.
*
*
* When you establish an AWS account, the account has initial limits on the maximum read capacity units and write
* capacity units that you can provision across all of your DynamoDB tables in a given region. Also, there are
* per-table limits that apply when you create a table there. For more information, see Limits page in the
* Amazon DynamoDB Developer Guide.
*
*
* Although you can increase these limits by filing a case at AWS Support Center, obtaining the increase is not
* instantaneous. The DescribeLimits action lets you write code to compare the capacity you are
* currently using to those limits imposed by your account so that you have enough time to apply for an increase
* before you hit a limit.
*
*
* For example, you could use one of the AWS SDKs to do the following:
*
*
* -
*
* Call DescribeLimits for a particular region to obtain your current account limits on provisioned
* capacity there.
*
*
* -
*
* Create a variable to hold the aggregate read capacity units provisioned for all your tables in that region, and
* one to hold the aggregate write capacity units. Zero them both.
*
*
* -
*
* Call ListTables to obtain a list of all your DynamoDB tables.
*
*
* -
*
* For each table name listed by ListTables, do the following:
*
*
* -
*
* Call DescribeTable with the table name.
*
*
* -
*
* Use the data returned by DescribeTable to add the read capacity units and write capacity units
* provisioned for the table itself to your variables.
*
*
* -
*
* If the table has one or more global secondary indexes (GSIs), loop over these GSIs and add their provisioned
* capacity values to your variables as well.
*
*
*
*
* -
*
* Report the account limits for that region returned by DescribeLimits, along with the total current
* provisioned capacity levels you have calculated.
*
*
*
*
* This will let you see whether you are getting close to your account-level limits.
*
*
* The per-table limits apply only when you are creating a new table. They restrict the sum of the provisioned
* capacity of the new table itself and all its global secondary indexes.
*
*
* For existing tables and their GSIs, DynamoDB will not let you increase provisioned capacity extremely rapidly,
* but the only upper limit that applies is that the aggregate provisioned capacity over all your tables and GSIs
* cannot exceed either of the per-account limits.
*
*
*
* DescribeLimits should only be called periodically. You can expect throttling errors if you call it
* more than once in a minute.
*
*
*
* The DescribeLimits Request element has no content.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeLimitsRequest.Builder} avoiding the need to
* create one manually via {@link DescribeLimitsRequest#builder()}
*
*
* @param describeLimitsRequest
* A {@link Consumer} that will call methods on {@link DescribeLimitsInput.Builder} to create a request.
* Represents the input of a DescribeLimits operation. Has no content.
* @return A Java Future containing the result of the DescribeLimits operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.DescribeLimits
* @see AWS API
* Documentation
*/
default CompletableFuture describeLimits(Consumer describeLimitsRequest) {
return describeLimits(DescribeLimitsRequest.builder().applyMutation(describeLimitsRequest).build());
}
/**
*
* Returns the current provisioned-capacity limits for your AWS account in a region, both for the region as a whole
* and for any one DynamoDB table that you create there.
*
*
* When you establish an AWS account, the account has initial limits on the maximum read capacity units and write
* capacity units that you can provision across all of your DynamoDB tables in a given region. Also, there are
* per-table limits that apply when you create a table there. For more information, see Limits page in the
* Amazon DynamoDB Developer Guide.
*
*
* Although you can increase these limits by filing a case at AWS Support Center, obtaining the increase is not
* instantaneous. The DescribeLimits action lets you write code to compare the capacity you are
* currently using to those limits imposed by your account so that you have enough time to apply for an increase
* before you hit a limit.
*
*
* For example, you could use one of the AWS SDKs to do the following:
*
*
* -
*
* Call DescribeLimits for a particular region to obtain your current account limits on provisioned
* capacity there.
*
*
* -
*
* Create a variable to hold the aggregate read capacity units provisioned for all your tables in that region, and
* one to hold the aggregate write capacity units. Zero them both.
*
*
* -
*
* Call ListTables to obtain a list of all your DynamoDB tables.
*
*
* -
*
* For each table name listed by ListTables, do the following:
*
*
* -
*
* Call DescribeTable with the table name.
*
*
* -
*
* Use the data returned by DescribeTable to add the read capacity units and write capacity units
* provisioned for the table itself to your variables.
*
*
* -
*
* If the table has one or more global secondary indexes (GSIs), loop over these GSIs and add their provisioned
* capacity values to your variables as well.
*
*
*
*
* -
*
* Report the account limits for that region returned by DescribeLimits, along with the total current
* provisioned capacity levels you have calculated.
*
*
*
*
* This will let you see whether you are getting close to your account-level limits.
*
*
* The per-table limits apply only when you are creating a new table. They restrict the sum of the provisioned
* capacity of the new table itself and all its global secondary indexes.
*
*
* For existing tables and their GSIs, DynamoDB will not let you increase provisioned capacity extremely rapidly,
* but the only upper limit that applies is that the aggregate provisioned capacity over all your tables and GSIs
* cannot exceed either of the per-account limits.
*
*
*
* DescribeLimits should only be called periodically. You can expect throttling errors if you call it
* more than once in a minute.
*
*
*
* The DescribeLimits Request element has no content.
*
*
* @return A Java Future containing the result of the DescribeLimits operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.DescribeLimits
* @see AWS API
* Documentation
*/
default CompletableFuture describeLimits() {
return describeLimits(DescribeLimitsRequest.builder().build());
}
/**
*
* Returns information about the table, including the current status of the table, when it was created, the primary
* key schema, and any indexes on the table.
*
*
*
* If you issue a DescribeTable request immediately after a CreateTable request, DynamoDB
* might return a ResourceNotFoundException. This is because DescribeTable uses an
* eventually consistent query, and the metadata for your table might not be available at that moment. Wait for a
* few seconds, and then try the DescribeTable request again.
*
*
*
* @param describeTableRequest
* Represents the input of a DescribeTable operation.
* @return A Java Future containing the result of the DescribeTable operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.DescribeTable
* @see AWS API
* Documentation
*/
default CompletableFuture describeTable(DescribeTableRequest describeTableRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns information about the table, including the current status of the table, when it was created, the primary
* key schema, and any indexes on the table.
*
*
*
* If you issue a DescribeTable request immediately after a CreateTable request, DynamoDB
* might return a ResourceNotFoundException. This is because DescribeTable uses an
* eventually consistent query, and the metadata for your table might not be available at that moment. Wait for a
* few seconds, and then try the DescribeTable request again.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeTableRequest.Builder} avoiding the need to
* create one manually via {@link DescribeTableRequest#builder()}
*
*
* @param describeTableRequest
* A {@link Consumer} that will call methods on {@link DescribeTableInput.Builder} to create a request.
* Represents the input of a DescribeTable operation.
* @return A Java Future containing the result of the DescribeTable operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.DescribeTable
* @see AWS API
* Documentation
*/
default CompletableFuture describeTable(Consumer describeTableRequest) {
return describeTable(DescribeTableRequest.builder().applyMutation(describeTableRequest).build());
}
/**
*
* Gives a description of the Time to Live (TTL) status on the specified table.
*
*
* @param describeTimeToLiveRequest
* @return A Java Future containing the result of the DescribeTimeToLive operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.DescribeTimeToLive
* @see AWS
* API Documentation
*/
default CompletableFuture describeTimeToLive(DescribeTimeToLiveRequest describeTimeToLiveRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Gives a description of the Time to Live (TTL) status on the specified table.
*
*
*
* This is a convenience which creates an instance of the {@link DescribeTimeToLiveRequest.Builder} avoiding the
* need to create one manually via {@link DescribeTimeToLiveRequest#builder()}
*
*
* @param describeTimeToLiveRequest
* A {@link Consumer} that will call methods on {@link DescribeTimeToLiveInput.Builder} to create a request.
* @return A Java Future containing the result of the DescribeTimeToLive operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.DescribeTimeToLive
* @see AWS
* API Documentation
*/
default CompletableFuture describeTimeToLive(
Consumer describeTimeToLiveRequest) {
return describeTimeToLive(DescribeTimeToLiveRequest.builder().applyMutation(describeTimeToLiveRequest).build());
}
/**
*
* The GetItem operation returns a set of attributes for the item with the given primary key. If there
* is no matching item, GetItem does not return any data and there will be no Item element
* in the response.
*
*
* GetItem provides an eventually consistent read by default. If your application requires a strongly
* consistent read, set ConsistentRead to true. Although a strongly consistent read might
* take more time than an eventually consistent read, it always returns the last updated value.
*
*
* @param getItemRequest
* Represents the input of a GetItem operation.
* @return A Java Future containing the result of the GetItem operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ProvisionedThroughputExceededException Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your request is eventually successful, unless
* your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff.
* For more information, go to Error Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.GetItem
* @see AWS API
* Documentation
*/
default CompletableFuture getItem(GetItemRequest getItemRequest) {
throw new UnsupportedOperationException();
}
/**
*
* The GetItem operation returns a set of attributes for the item with the given primary key. If there
* is no matching item, GetItem does not return any data and there will be no Item element
* in the response.
*
*
* GetItem provides an eventually consistent read by default. If your application requires a strongly
* consistent read, set ConsistentRead to true. Although a strongly consistent read might
* take more time than an eventually consistent read, it always returns the last updated value.
*
*
*
* This is a convenience which creates an instance of the {@link GetItemRequest.Builder} avoiding the need to create
* one manually via {@link GetItemRequest#builder()}
*
*
* @param getItemRequest
* A {@link Consumer} that will call methods on {@link GetItemInput.Builder} to create a request. Represents
* the input of a GetItem operation.
* @return A Java Future containing the result of the GetItem operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ProvisionedThroughputExceededException Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your request is eventually successful, unless
* your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff.
* For more information, go to Error Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.GetItem
* @see AWS API
* Documentation
*/
default CompletableFuture getItem(Consumer getItemRequest) {
return getItem(GetItemRequest.builder().applyMutation(getItemRequest).build());
}
/**
*
* List backups associated with an AWS account. To list backups for a given table, specify TableName.
* ListBackups returns a paginated list of results with at most 1MB worth of items in a page. You can
* also specify a limit for the maximum number of entries to be returned in a page.
*
*
* In the request, start time is inclusive but end time is exclusive. Note that these limits are for the time at
* which the original backup was requested.
*
*
* You can call ListBackups a maximum of 5 times per second.
*
*
* @param listBackupsRequest
* @return A Java Future containing the result of the ListBackups operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.ListBackups
* @see AWS API
* Documentation
*/
default CompletableFuture listBackups(ListBackupsRequest listBackupsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* List backups associated with an AWS account. To list backups for a given table, specify TableName.
* ListBackups returns a paginated list of results with at most 1MB worth of items in a page. You can
* also specify a limit for the maximum number of entries to be returned in a page.
*
*
* In the request, start time is inclusive but end time is exclusive. Note that these limits are for the time at
* which the original backup was requested.
*
*
* You can call ListBackups a maximum of 5 times per second.
*
*
*
* This is a convenience which creates an instance of the {@link ListBackupsRequest.Builder} avoiding the need to
* create one manually via {@link ListBackupsRequest#builder()}
*
*
* @param listBackupsRequest
* A {@link Consumer} that will call methods on {@link ListBackupsInput.Builder} to create a request.
* @return A Java Future containing the result of the ListBackups operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.ListBackups
* @see AWS API
* Documentation
*/
default CompletableFuture listBackups(Consumer listBackupsRequest) {
return listBackups(ListBackupsRequest.builder().applyMutation(listBackupsRequest).build());
}
/**
*
* List backups associated with an AWS account. To list backups for a given table, specify TableName.
* ListBackups returns a paginated list of results with at most 1MB worth of items in a page. You can
* also specify a limit for the maximum number of entries to be returned in a page.
*
*
* In the request, start time is inclusive but end time is exclusive. Note that these limits are for the time at
* which the original backup was requested.
*
*
* You can call ListBackups a maximum of 5 times per second.
*
*
* @return A Java Future containing the result of the ListBackups operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.ListBackups
* @see AWS API
* Documentation
*/
default CompletableFuture listBackups() {
return listBackups(ListBackupsRequest.builder().build());
}
/**
*
* Lists all global tables that have a replica in the specified region.
*
*
* @param listGlobalTablesRequest
* @return A Java Future containing the result of the ListGlobalTables operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.ListGlobalTables
* @see AWS API
* Documentation
*/
default CompletableFuture listGlobalTables(ListGlobalTablesRequest listGlobalTablesRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Lists all global tables that have a replica in the specified region.
*
*
*
* This is a convenience which creates an instance of the {@link ListGlobalTablesRequest.Builder} avoiding the need
* to create one manually via {@link ListGlobalTablesRequest#builder()}
*
*
* @param listGlobalTablesRequest
* A {@link Consumer} that will call methods on {@link ListGlobalTablesInput.Builder} to create a request.
* @return A Java Future containing the result of the ListGlobalTables operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.ListGlobalTables
* @see AWS API
* Documentation
*/
default CompletableFuture listGlobalTables(
Consumer listGlobalTablesRequest) {
return listGlobalTables(ListGlobalTablesRequest.builder().applyMutation(listGlobalTablesRequest).build());
}
/**
*
* Lists all global tables that have a replica in the specified region.
*
*
* @return A Java Future containing the result of the ListGlobalTables operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.ListGlobalTables
* @see AWS API
* Documentation
*/
default CompletableFuture listGlobalTables() {
return listGlobalTables(ListGlobalTablesRequest.builder().build());
}
/**
*
* Returns an array of table names associated with the current account and endpoint. The output from
* ListTables is paginated, with each page returning a maximum of 100 table names.
*
*
* @param listTablesRequest
* Represents the input of a ListTables operation.
* @return A Java Future containing the result of the ListTables operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.ListTables
* @see AWS API
* Documentation
*/
default CompletableFuture listTables(ListTablesRequest listTablesRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns an array of table names associated with the current account and endpoint. The output from
* ListTables is paginated, with each page returning a maximum of 100 table names.
*
*
*
* This is a convenience which creates an instance of the {@link ListTablesRequest.Builder} avoiding the need to
* create one manually via {@link ListTablesRequest#builder()}
*
*
* @param listTablesRequest
* A {@link Consumer} that will call methods on {@link ListTablesInput.Builder} to create a request.
* Represents the input of a ListTables operation.
* @return A Java Future containing the result of the ListTables operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.ListTables
* @see AWS API
* Documentation
*/
default CompletableFuture listTables(Consumer listTablesRequest) {
return listTables(ListTablesRequest.builder().applyMutation(listTablesRequest).build());
}
/**
*
* Returns an array of table names associated with the current account and endpoint. The output from
* ListTables is paginated, with each page returning a maximum of 100 table names.
*
*
* @return A Java Future containing the result of the ListTables operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.ListTables
* @see AWS API
* Documentation
*/
default CompletableFuture listTables() {
return listTables(ListTablesRequest.builder().build());
}
/**
*
* Returns an array of table names associated with the current account and endpoint. The output from
* ListTables is paginated, with each page returning a maximum of 100 table names.
*
*
*
* This is a variant of {@link #listTables(software.amazon.awssdk.services.dynamodb.model.ListTablesRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the forEach helper method
*
*
* {@code
* software.amazon.awssdk.services.dynamodb.paginators.ListTablesPublisher publisher = client.listTablesPaginator(request);
* CompletableFuture future = publisher.forEach(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.dynamodb.paginators.ListTablesPublisher publisher = client.listTablesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.dynamodb.model.ListTablesResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Note: If you prefer to have control on service calls, use the
* {@link #listTables(software.amazon.awssdk.services.dynamodb.model.ListTablesRequest)} operation.
*
*
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.ListTables
* @see AWS API
* Documentation
*/
default ListTablesPublisher listTablesPaginator() {
return listTablesPaginator(ListTablesRequest.builder().build());
}
/**
*
* Returns an array of table names associated with the current account and endpoint. The output from
* ListTables is paginated, with each page returning a maximum of 100 table names.
*
*
*
* This is a variant of {@link #listTables(software.amazon.awssdk.services.dynamodb.model.ListTablesRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the forEach helper method
*
*
* {@code
* software.amazon.awssdk.services.dynamodb.paginators.ListTablesPublisher publisher = client.listTablesPaginator(request);
* CompletableFuture future = publisher.forEach(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.dynamodb.paginators.ListTablesPublisher publisher = client.listTablesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.dynamodb.model.ListTablesResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Note: If you prefer to have control on service calls, use the
* {@link #listTables(software.amazon.awssdk.services.dynamodb.model.ListTablesRequest)} operation.
*
*
* @param listTablesRequest
* Represents the input of a ListTables operation.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.ListTables
* @see AWS API
* Documentation
*/
default ListTablesPublisher listTablesPaginator(ListTablesRequest listTablesRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns an array of table names associated with the current account and endpoint. The output from
* ListTables is paginated, with each page returning a maximum of 100 table names.
*
*
*
* This is a variant of {@link #listTables(software.amazon.awssdk.services.dynamodb.model.ListTablesRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the forEach helper method
*
*
* {@code
* software.amazon.awssdk.services.dynamodb.paginators.ListTablesPublisher publisher = client.listTablesPaginator(request);
* CompletableFuture future = publisher.forEach(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.dynamodb.paginators.ListTablesPublisher publisher = client.listTablesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.dynamodb.model.ListTablesResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Note: If you prefer to have control on service calls, use the
* {@link #listTables(software.amazon.awssdk.services.dynamodb.model.ListTablesRequest)} operation.
*
*
* This is a convenience which creates an instance of the {@link ListTablesRequest.Builder} avoiding the need to
* create one manually via {@link ListTablesRequest#builder()}
*
*
* @param listTablesRequest
* A {@link Consumer} that will call methods on {@link ListTablesInput.Builder} to create a request.
* Represents the input of a ListTables operation.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.ListTables
* @see AWS API
* Documentation
*/
default ListTablesPublisher listTablesPaginator(Consumer listTablesRequest) {
return listTablesPaginator(ListTablesRequest.builder().applyMutation(listTablesRequest).build());
}
/**
*
* List all tags on an Amazon DynamoDB resource. You can call ListTagsOfResource up to 10 times per second, per
* account.
*
*
* For an overview on tagging DynamoDB resources, see Tagging for DynamoDB in
* the Amazon DynamoDB Developer Guide.
*
*
* @param listTagsOfResourceRequest
* @return A Java Future containing the result of the ListTagsOfResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.ListTagsOfResource
* @see AWS
* API Documentation
*/
default CompletableFuture listTagsOfResource(ListTagsOfResourceRequest listTagsOfResourceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* List all tags on an Amazon DynamoDB resource. You can call ListTagsOfResource up to 10 times per second, per
* account.
*
*
* For an overview on tagging DynamoDB resources, see Tagging for DynamoDB in
* the Amazon DynamoDB Developer Guide.
*
*
*
* This is a convenience which creates an instance of the {@link ListTagsOfResourceRequest.Builder} avoiding the
* need to create one manually via {@link ListTagsOfResourceRequest#builder()}
*
*
* @param listTagsOfResourceRequest
* A {@link Consumer} that will call methods on {@link ListTagsOfResourceInput.Builder} to create a request.
* @return A Java Future containing the result of the ListTagsOfResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.ListTagsOfResource
* @see AWS
* API Documentation
*/
default CompletableFuture listTagsOfResource(
Consumer listTagsOfResourceRequest) {
return listTagsOfResource(ListTagsOfResourceRequest.builder().applyMutation(listTagsOfResourceRequest).build());
}
/**
*
* Creates a new item, or replaces an old item with a new item. If an item that has the same primary key as the new
* item already exists in the specified table, the new item completely replaces the existing item. You can perform a
* conditional put operation (add a new item if one with the specified primary key doesn't exist), or replace an
* existing item if it has certain attribute values. You can return the item's attribute values in the same
* operation, using the ReturnValues parameter.
*
*
*
* This topic provides general information about the PutItem API.
*
*
* For information on how to call the PutItem API using the AWS SDK in specific languages, see the
* following:
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
*
*
*
* When you add an item, the primary key attribute(s) are the only required attributes. Attribute values cannot be
* null. String and Binary type attributes must have lengths greater than zero. Set type attributes cannot be empty.
* Requests with empty values will be rejected with a ValidationException exception.
*
*
*
* To prevent a new item from replacing an existing item, use a conditional expression that contains the
* attribute_not_exists function with the name of the attribute being used as the partition key for the
* table. Since every record must contain that attribute, the attribute_not_exists function will only
* succeed if no matching item exists.
*
*
*
* For more information about PutItem, see Working with
* Items in the Amazon DynamoDB Developer Guide.
*
*
* @param putItemRequest
* Represents the input of a PutItem operation.
* @return A Java Future containing the result of the PutItem operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ConditionalCheckFailedException A condition specified in the operation could not be evaluated.
* - ProvisionedThroughputExceededException Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your request is eventually successful, unless
* your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff.
* For more information, go to Error Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - ItemCollectionSizeLimitExceededException An item collection is too large. This exception is only
* returned for tables that have one or more local secondary indexes.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.PutItem
* @see AWS API
* Documentation
*/
default CompletableFuture putItem(PutItemRequest putItemRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates a new item, or replaces an old item with a new item. If an item that has the same primary key as the new
* item already exists in the specified table, the new item completely replaces the existing item. You can perform a
* conditional put operation (add a new item if one with the specified primary key doesn't exist), or replace an
* existing item if it has certain attribute values. You can return the item's attribute values in the same
* operation, using the ReturnValues parameter.
*
*
*
* This topic provides general information about the PutItem API.
*
*
* For information on how to call the PutItem API using the AWS SDK in specific languages, see the
* following:
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
*
*
*
* When you add an item, the primary key attribute(s) are the only required attributes. Attribute values cannot be
* null. String and Binary type attributes must have lengths greater than zero. Set type attributes cannot be empty.
* Requests with empty values will be rejected with a ValidationException exception.
*
*
*
* To prevent a new item from replacing an existing item, use a conditional expression that contains the
* attribute_not_exists function with the name of the attribute being used as the partition key for the
* table. Since every record must contain that attribute, the attribute_not_exists function will only
* succeed if no matching item exists.
*
*
*
* For more information about PutItem, see Working with
* Items in the Amazon DynamoDB Developer Guide.
*
*
*
* This is a convenience which creates an instance of the {@link PutItemRequest.Builder} avoiding the need to create
* one manually via {@link PutItemRequest#builder()}
*
*
* @param putItemRequest
* A {@link Consumer} that will call methods on {@link PutItemInput.Builder} to create a request. Represents
* the input of a PutItem operation.
* @return A Java Future containing the result of the PutItem operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ConditionalCheckFailedException A condition specified in the operation could not be evaluated.
* - ProvisionedThroughputExceededException Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your request is eventually successful, unless
* your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff.
* For more information, go to Error Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - ItemCollectionSizeLimitExceededException An item collection is too large. This exception is only
* returned for tables that have one or more local secondary indexes.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.PutItem
* @see AWS API
* Documentation
*/
default CompletableFuture putItem(Consumer putItemRequest) {
return putItem(PutItemRequest.builder().applyMutation(putItemRequest).build());
}
/**
*
* The Query operation finds items based on primary key values. You can query any table or secondary
* index that has a composite primary key (a partition key and a sort key).
*
*
* Use the KeyConditionExpression parameter to provide a specific value for the partition key. The
* Query operation will return all of the items from the table or index with that partition key value.
* You can optionally narrow the scope of the Query operation by specifying a sort key value and a
* comparison operator in KeyConditionExpression. To further refine the Query results, you
* can optionally provide a FilterExpression. A FilterExpression determines which items
* within the results should be returned to you. All of the other results are discarded.
*
*
* A Query operation always returns a result set. If no matching items are found, the result set will
* be empty. Queries that do not return results consume the minimum number of read capacity units for that type of
* read operation.
*
*
*
* DynamoDB calculates the number of read capacity units consumed based on item size, not on the amount of data that
* is returned to an application. The number of capacity units consumed will be the same whether you request all of
* the attributes (the default behavior) or just some of them (using a projection expression). The number will also
* be the same whether or not you use a FilterExpression.
*
*
*
* Query results are always sorted by the sort key value. If the data type of the sort key is Number,
* the results are returned in numeric order; otherwise, the results are returned in order of UTF-8 bytes. By
* default, the sort order is ascending. To reverse the order, set the ScanIndexForward parameter to
* false.
*
*
* A single Query operation will read up to the maximum number of items set (if using the
* Limit parameter) or a maximum of 1 MB of data and then apply any filtering to the results using
* FilterExpression. If LastEvaluatedKey is present in the response, you will need to
* paginate the result set. For more information, see Paginating the
* Results in the Amazon DynamoDB Developer Guide.
*
*
* FilterExpression is applied after a Query finishes, but before the results are
* returned. A FilterExpression cannot contain partition key or sort key attributes. You need to
* specify those attributes in the KeyConditionExpression.
*
*
*
* A Query operation can return an empty result set and a LastEvaluatedKey if all the
* items read for the page of results are filtered out.
*
*
*
* You can query a table, a local secondary index, or a global secondary index. For a query on a table or on a local
* secondary index, you can set the ConsistentRead parameter to true and obtain a strongly
* consistent result. Global secondary indexes support eventually consistent reads only, so do not specify
* ConsistentRead when querying a global secondary index.
*
*
* @param queryRequest
* Represents the input of a Query operation.
* @return A Java Future containing the result of the Query operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ProvisionedThroughputExceededException Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your request is eventually successful, unless
* your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff.
* For more information, go to Error Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.Query
* @see AWS API
* Documentation
*/
default CompletableFuture query(QueryRequest queryRequest) {
throw new UnsupportedOperationException();
}
/**
*
* The Query operation finds items based on primary key values. You can query any table or secondary
* index that has a composite primary key (a partition key and a sort key).
*
*
* Use the KeyConditionExpression parameter to provide a specific value for the partition key. The
* Query operation will return all of the items from the table or index with that partition key value.
* You can optionally narrow the scope of the Query operation by specifying a sort key value and a
* comparison operator in KeyConditionExpression. To further refine the Query results, you
* can optionally provide a FilterExpression. A FilterExpression determines which items
* within the results should be returned to you. All of the other results are discarded.
*
*
* A Query operation always returns a result set. If no matching items are found, the result set will
* be empty. Queries that do not return results consume the minimum number of read capacity units for that type of
* read operation.
*
*
*
* DynamoDB calculates the number of read capacity units consumed based on item size, not on the amount of data that
* is returned to an application. The number of capacity units consumed will be the same whether you request all of
* the attributes (the default behavior) or just some of them (using a projection expression). The number will also
* be the same whether or not you use a FilterExpression.
*
*
*
* Query results are always sorted by the sort key value. If the data type of the sort key is Number,
* the results are returned in numeric order; otherwise, the results are returned in order of UTF-8 bytes. By
* default, the sort order is ascending. To reverse the order, set the ScanIndexForward parameter to
* false.
*
*
* A single Query operation will read up to the maximum number of items set (if using the
* Limit parameter) or a maximum of 1 MB of data and then apply any filtering to the results using
* FilterExpression. If LastEvaluatedKey is present in the response, you will need to
* paginate the result set. For more information, see Paginating the
* Results in the Amazon DynamoDB Developer Guide.
*
*
* FilterExpression is applied after a Query finishes, but before the results are
* returned. A FilterExpression cannot contain partition key or sort key attributes. You need to
* specify those attributes in the KeyConditionExpression.
*
*
*
* A Query operation can return an empty result set and a LastEvaluatedKey if all the
* items read for the page of results are filtered out.
*
*
*
* You can query a table, a local secondary index, or a global secondary index. For a query on a table or on a local
* secondary index, you can set the ConsistentRead parameter to true and obtain a strongly
* consistent result. Global secondary indexes support eventually consistent reads only, so do not specify
* ConsistentRead when querying a global secondary index.
*
*
*
* This is a convenience which creates an instance of the {@link QueryRequest.Builder} avoiding the need to create
* one manually via {@link QueryRequest#builder()}
*
*
* @param queryRequest
* A {@link Consumer} that will call methods on {@link QueryInput.Builder} to create a request. Represents
* the input of a Query operation.
* @return A Java Future containing the result of the Query operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ProvisionedThroughputExceededException Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your request is eventually successful, unless
* your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff.
* For more information, go to Error Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.Query
* @see AWS API
* Documentation
*/
default CompletableFuture query(Consumer queryRequest) {
return query(QueryRequest.builder().applyMutation(queryRequest).build());
}
/**
*
* The Query operation finds items based on primary key values. You can query any table or secondary
* index that has a composite primary key (a partition key and a sort key).
*
*
* Use the KeyConditionExpression parameter to provide a specific value for the partition key. The
* Query operation will return all of the items from the table or index with that partition key value.
* You can optionally narrow the scope of the Query operation by specifying a sort key value and a
* comparison operator in KeyConditionExpression. To further refine the Query results, you
* can optionally provide a FilterExpression. A FilterExpression determines which items
* within the results should be returned to you. All of the other results are discarded.
*
*
* A Query operation always returns a result set. If no matching items are found, the result set will
* be empty. Queries that do not return results consume the minimum number of read capacity units for that type of
* read operation.
*
*
*
* DynamoDB calculates the number of read capacity units consumed based on item size, not on the amount of data that
* is returned to an application. The number of capacity units consumed will be the same whether you request all of
* the attributes (the default behavior) or just some of them (using a projection expression). The number will also
* be the same whether or not you use a FilterExpression.
*
*
*
* Query results are always sorted by the sort key value. If the data type of the sort key is Number,
* the results are returned in numeric order; otherwise, the results are returned in order of UTF-8 bytes. By
* default, the sort order is ascending. To reverse the order, set the ScanIndexForward parameter to
* false.
*
*
* A single Query operation will read up to the maximum number of items set (if using the
* Limit parameter) or a maximum of 1 MB of data and then apply any filtering to the results using
* FilterExpression. If LastEvaluatedKey is present in the response, you will need to
* paginate the result set. For more information, see Paginating the
* Results in the Amazon DynamoDB Developer Guide.
*
*
* FilterExpression is applied after a Query finishes, but before the results are
* returned. A FilterExpression cannot contain partition key or sort key attributes. You need to
* specify those attributes in the KeyConditionExpression.
*
*
*
* A Query operation can return an empty result set and a LastEvaluatedKey if all the
* items read for the page of results are filtered out.
*
*
*
* You can query a table, a local secondary index, or a global secondary index. For a query on a table or on a local
* secondary index, you can set the ConsistentRead parameter to true and obtain a strongly
* consistent result. Global secondary indexes support eventually consistent reads only, so do not specify
* ConsistentRead when querying a global secondary index.
*
*
*
* This is a variant of {@link #query(software.amazon.awssdk.services.dynamodb.model.QueryRequest)} operation. The
* return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the forEach helper method
*
*
* {@code
* software.amazon.awssdk.services.dynamodb.paginators.QueryPublisher publisher = client.queryPaginator(request);
* CompletableFuture future = publisher.forEach(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.dynamodb.paginators.QueryPublisher publisher = client.queryPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.dynamodb.model.QueryResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Note: If you prefer to have control on service calls, use the
* {@link #query(software.amazon.awssdk.services.dynamodb.model.QueryRequest)} operation.
*
*
* @param queryRequest
* Represents the input of a Query operation.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ProvisionedThroughputExceededException Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your request is eventually successful, unless
* your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff.
* For more information, go to Error Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.Query
* @see AWS API
* Documentation
*/
default QueryPublisher queryPaginator(QueryRequest queryRequest) {
throw new UnsupportedOperationException();
}
/**
*
* The Query operation finds items based on primary key values. You can query any table or secondary
* index that has a composite primary key (a partition key and a sort key).
*
*
* Use the KeyConditionExpression parameter to provide a specific value for the partition key. The
* Query operation will return all of the items from the table or index with that partition key value.
* You can optionally narrow the scope of the Query operation by specifying a sort key value and a
* comparison operator in KeyConditionExpression. To further refine the Query results, you
* can optionally provide a FilterExpression. A FilterExpression determines which items
* within the results should be returned to you. All of the other results are discarded.
*
*
* A Query operation always returns a result set. If no matching items are found, the result set will
* be empty. Queries that do not return results consume the minimum number of read capacity units for that type of
* read operation.
*
*
*
* DynamoDB calculates the number of read capacity units consumed based on item size, not on the amount of data that
* is returned to an application. The number of capacity units consumed will be the same whether you request all of
* the attributes (the default behavior) or just some of them (using a projection expression). The number will also
* be the same whether or not you use a FilterExpression.
*
*
*
* Query results are always sorted by the sort key value. If the data type of the sort key is Number,
* the results are returned in numeric order; otherwise, the results are returned in order of UTF-8 bytes. By
* default, the sort order is ascending. To reverse the order, set the ScanIndexForward parameter to
* false.
*
*
* A single Query operation will read up to the maximum number of items set (if using the
* Limit parameter) or a maximum of 1 MB of data and then apply any filtering to the results using
* FilterExpression. If LastEvaluatedKey is present in the response, you will need to
* paginate the result set. For more information, see Paginating the
* Results in the Amazon DynamoDB Developer Guide.
*
*
* FilterExpression is applied after a Query finishes, but before the results are
* returned. A FilterExpression cannot contain partition key or sort key attributes. You need to
* specify those attributes in the KeyConditionExpression.
*
*
*
* A Query operation can return an empty result set and a LastEvaluatedKey if all the
* items read for the page of results are filtered out.
*
*
*
* You can query a table, a local secondary index, or a global secondary index. For a query on a table or on a local
* secondary index, you can set the ConsistentRead parameter to true and obtain a strongly
* consistent result. Global secondary indexes support eventually consistent reads only, so do not specify
* ConsistentRead when querying a global secondary index.
*
*
*
* This is a variant of {@link #query(software.amazon.awssdk.services.dynamodb.model.QueryRequest)} operation. The
* return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the forEach helper method
*
*
* {@code
* software.amazon.awssdk.services.dynamodb.paginators.QueryPublisher publisher = client.queryPaginator(request);
* CompletableFuture future = publisher.forEach(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.dynamodb.paginators.QueryPublisher publisher = client.queryPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.dynamodb.model.QueryResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Note: If you prefer to have control on service calls, use the
* {@link #query(software.amazon.awssdk.services.dynamodb.model.QueryRequest)} operation.
*
*
* This is a convenience which creates an instance of the {@link QueryRequest.Builder} avoiding the need to create
* one manually via {@link QueryRequest#builder()}
*
*
* @param queryRequest
* A {@link Consumer} that will call methods on {@link QueryInput.Builder} to create a request. Represents
* the input of a Query operation.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ProvisionedThroughputExceededException Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your request is eventually successful, unless
* your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff.
* For more information, go to Error Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.Query
* @see AWS API
* Documentation
*/
default QueryPublisher queryPaginator(Consumer queryRequest) {
return queryPaginator(QueryRequest.builder().applyMutation(queryRequest).build());
}
/**
*
* Creates a new table from an existing backup. Any number of users can execute up to 4 concurrent restores (any
* type of restore) in a given account.
*
*
* You can call RestoreTableFromBackup at a maximum rate of 10 times per second.
*
*
* You must manually set up the following on the restored table:
*
*
* -
*
* Auto scaling policies
*
*
* -
*
* IAM policies
*
*
* -
*
* Cloudwatch metrics and alarms
*
*
* -
*
* Tags
*
*
* -
*
* Stream settings
*
*
* -
*
* Time to Live (TTL) settings
*
*
*
*
* @param restoreTableFromBackupRequest
* @return A Java Future containing the result of the RestoreTableFromBackup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - TableAlreadyExistsException A target table with the specified name already exists.
* - TableInUseException A target table with the specified name is either being created or deleted.
* - BackupNotFoundException Backup not found for the given BackupARN.
* - BackupInUseException There is another ongoing conflicting backup control plane operation on the
* table. The backups is either being created, deleted or restored to a table.
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.RestoreTableFromBackup
* @see AWS API Documentation
*/
default CompletableFuture restoreTableFromBackup(
RestoreTableFromBackupRequest restoreTableFromBackupRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates a new table from an existing backup. Any number of users can execute up to 4 concurrent restores (any
* type of restore) in a given account.
*
*
* You can call RestoreTableFromBackup at a maximum rate of 10 times per second.
*
*
* You must manually set up the following on the restored table:
*
*
* -
*
* Auto scaling policies
*
*
* -
*
* IAM policies
*
*
* -
*
* Cloudwatch metrics and alarms
*
*
* -
*
* Tags
*
*
* -
*
* Stream settings
*
*
* -
*
* Time to Live (TTL) settings
*
*
*
*
*
* This is a convenience which creates an instance of the {@link RestoreTableFromBackupRequest.Builder} avoiding the
* need to create one manually via {@link RestoreTableFromBackupRequest#builder()}
*
*
* @param restoreTableFromBackupRequest
* A {@link Consumer} that will call methods on {@link RestoreTableFromBackupInput.Builder} to create a
* request.
* @return A Java Future containing the result of the RestoreTableFromBackup operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - TableAlreadyExistsException A target table with the specified name already exists.
* - TableInUseException A target table with the specified name is either being created or deleted.
* - BackupNotFoundException Backup not found for the given BackupARN.
* - BackupInUseException There is another ongoing conflicting backup control plane operation on the
* table. The backups is either being created, deleted or restored to a table.
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.RestoreTableFromBackup
* @see AWS API Documentation
*/
default CompletableFuture restoreTableFromBackup(
Consumer restoreTableFromBackupRequest) {
return restoreTableFromBackup(RestoreTableFromBackupRequest.builder().applyMutation(restoreTableFromBackupRequest)
.build());
}
/**
*
* Restores the specified table to the specified point in time within EarliestRestorableDateTime and
* LatestRestorableDateTime. You can restore your table to any point in time during the last 35 days.
* Any number of users can execute up to 4 concurrent restores (any type of restore) in a given account.
*
*
* When you restore using point in time recovery, DynamoDB restores your table data to the state based on the
* selected date and time (day:hour:minute:second) to a new table.
*
*
* Along with data, the following are also included on the new restored table using point in time recovery:
*
*
* -
*
* Global secondary indexes (GSIs)
*
*
* -
*
* Local secondary indexes (LSIs)
*
*
* -
*
* Provisioned read and write capacity
*
*
* -
*
* Encryption settings
*
*
*
* All these settings come from the current settings of the source table at the time of restore.
*
*
*
*
* You must manually set up the following on the restored table:
*
*
* -
*
* Auto scaling policies
*
*
* -
*
* IAM policies
*
*
* -
*
* Cloudwatch metrics and alarms
*
*
* -
*
* Tags
*
*
* -
*
* Stream settings
*
*
* -
*
* Time to Live (TTL) settings
*
*
* -
*
* Point in time recovery settings
*
*
*
*
* @param restoreTableToPointInTimeRequest
* @return A Java Future containing the result of the RestoreTableToPointInTime operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - TableAlreadyExistsException A target table with the specified name already exists.
* - TableNotFoundException A source table with the name
TableName does not currently exist
* within the subscriber's account.
* - TableInUseException A target table with the specified name is either being created or deleted.
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - InvalidRestoreTimeException An invalid restore time was specified. RestoreDateTime must be between
* EarliestRestorableDateTime and LatestRestorableDateTime.
* - PointInTimeRecoveryUnavailableException Point in time recovery has not yet been enabled for this
* source table.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.RestoreTableToPointInTime
* @see AWS API Documentation
*/
default CompletableFuture restoreTableToPointInTime(
RestoreTableToPointInTimeRequest restoreTableToPointInTimeRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Restores the specified table to the specified point in time within EarliestRestorableDateTime and
* LatestRestorableDateTime. You can restore your table to any point in time during the last 35 days.
* Any number of users can execute up to 4 concurrent restores (any type of restore) in a given account.
*
*
* When you restore using point in time recovery, DynamoDB restores your table data to the state based on the
* selected date and time (day:hour:minute:second) to a new table.
*
*
* Along with data, the following are also included on the new restored table using point in time recovery:
*
*
* -
*
* Global secondary indexes (GSIs)
*
*
* -
*
* Local secondary indexes (LSIs)
*
*
* -
*
* Provisioned read and write capacity
*
*
* -
*
* Encryption settings
*
*
*
* All these settings come from the current settings of the source table at the time of restore.
*
*
*
*
* You must manually set up the following on the restored table:
*
*
* -
*
* Auto scaling policies
*
*
* -
*
* IAM policies
*
*
* -
*
* Cloudwatch metrics and alarms
*
*
* -
*
* Tags
*
*
* -
*
* Stream settings
*
*
* -
*
* Time to Live (TTL) settings
*
*
* -
*
* Point in time recovery settings
*
*
*
*
*
* This is a convenience which creates an instance of the {@link RestoreTableToPointInTimeRequest.Builder} avoiding
* the need to create one manually via {@link RestoreTableToPointInTimeRequest#builder()}
*
*
* @param restoreTableToPointInTimeRequest
* A {@link Consumer} that will call methods on {@link RestoreTableToPointInTimeInput.Builder} to create a
* request.
* @return A Java Future containing the result of the RestoreTableToPointInTime operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - TableAlreadyExistsException A target table with the specified name already exists.
* - TableNotFoundException A source table with the name
TableName does not currently exist
* within the subscriber's account.
* - TableInUseException A target table with the specified name is either being created or deleted.
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - InvalidRestoreTimeException An invalid restore time was specified. RestoreDateTime must be between
* EarliestRestorableDateTime and LatestRestorableDateTime.
* - PointInTimeRecoveryUnavailableException Point in time recovery has not yet been enabled for this
* source table.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.RestoreTableToPointInTime
* @see AWS API Documentation
*/
default CompletableFuture restoreTableToPointInTime(
Consumer restoreTableToPointInTimeRequest) {
return restoreTableToPointInTime(RestoreTableToPointInTimeRequest.builder()
.applyMutation(restoreTableToPointInTimeRequest).build());
}
/**
*
* The Scan operation returns one or more items and item attributes by accessing every item in a table
* or a secondary index. To have DynamoDB return fewer items, you can provide a FilterExpression
* operation.
*
*
* If the total number of scanned items exceeds the maximum data set size limit of 1 MB, the scan stops and results
* are returned to the user as a LastEvaluatedKey value to continue the scan in a subsequent operation.
* The results also include the number of items exceeding the limit. A scan can result in no table data meeting the
* filter criteria.
*
*
* A single Scan operation will read up to the maximum number of items set (if using the
* Limit parameter) or a maximum of 1 MB of data and then apply any filtering to the results using
* FilterExpression. If LastEvaluatedKey is present in the response, you will need to
* paginate the result set. For more information, see Paginating the
* Results in the Amazon DynamoDB Developer Guide.
*
*
* Scan operations proceed sequentially; however, for faster performance on a large table or secondary
* index, applications can request a parallel Scan operation by providing the Segment and
* TotalSegments parameters. For more information, see Parallel
* Scan in the Amazon DynamoDB Developer Guide.
*
*
* Scan uses eventually consistent reads when accessing the data in a table; therefore, the result set
* might not include the changes to data in the table immediately before the operation began. If you need a
* consistent copy of the data, as of the time that the Scan begins, you can set the
* ConsistentRead parameter to true.
*
*
* @param scanRequest
* Represents the input of a Scan operation.
* @return A Java Future containing the result of the Scan operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ProvisionedThroughputExceededException Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your request is eventually successful, unless
* your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff.
* For more information, go to Error Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.Scan
* @see AWS API
* Documentation
*/
default CompletableFuture scan(ScanRequest scanRequest) {
throw new UnsupportedOperationException();
}
/**
*
* The Scan operation returns one or more items and item attributes by accessing every item in a table
* or a secondary index. To have DynamoDB return fewer items, you can provide a FilterExpression
* operation.
*
*
* If the total number of scanned items exceeds the maximum data set size limit of 1 MB, the scan stops and results
* are returned to the user as a LastEvaluatedKey value to continue the scan in a subsequent operation.
* The results also include the number of items exceeding the limit. A scan can result in no table data meeting the
* filter criteria.
*
*
* A single Scan operation will read up to the maximum number of items set (if using the
* Limit parameter) or a maximum of 1 MB of data and then apply any filtering to the results using
* FilterExpression. If LastEvaluatedKey is present in the response, you will need to
* paginate the result set. For more information, see Paginating the
* Results in the Amazon DynamoDB Developer Guide.
*
*
* Scan operations proceed sequentially; however, for faster performance on a large table or secondary
* index, applications can request a parallel Scan operation by providing the Segment and
* TotalSegments parameters. For more information, see Parallel
* Scan in the Amazon DynamoDB Developer Guide.
*
*
* Scan uses eventually consistent reads when accessing the data in a table; therefore, the result set
* might not include the changes to data in the table immediately before the operation began. If you need a
* consistent copy of the data, as of the time that the Scan begins, you can set the
* ConsistentRead parameter to true.
*
*
*
* This is a convenience which creates an instance of the {@link ScanRequest.Builder} avoiding the need to create
* one manually via {@link ScanRequest#builder()}
*
*
* @param scanRequest
* A {@link Consumer} that will call methods on {@link ScanInput.Builder} to create a request. Represents the
* input of a Scan operation.
* @return A Java Future containing the result of the Scan operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ProvisionedThroughputExceededException Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your request is eventually successful, unless
* your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff.
* For more information, go to Error Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.Scan
* @see AWS API
* Documentation
*/
default CompletableFuture scan(Consumer scanRequest) {
return scan(ScanRequest.builder().applyMutation(scanRequest).build());
}
/**
*
* The Scan operation returns one or more items and item attributes by accessing every item in a table
* or a secondary index. To have DynamoDB return fewer items, you can provide a FilterExpression
* operation.
*
*
* If the total number of scanned items exceeds the maximum data set size limit of 1 MB, the scan stops and results
* are returned to the user as a LastEvaluatedKey value to continue the scan in a subsequent operation.
* The results also include the number of items exceeding the limit. A scan can result in no table data meeting the
* filter criteria.
*
*
* A single Scan operation will read up to the maximum number of items set (if using the
* Limit parameter) or a maximum of 1 MB of data and then apply any filtering to the results using
* FilterExpression. If LastEvaluatedKey is present in the response, you will need to
* paginate the result set. For more information, see Paginating the
* Results in the Amazon DynamoDB Developer Guide.
*
*
* Scan operations proceed sequentially; however, for faster performance on a large table or secondary
* index, applications can request a parallel Scan operation by providing the Segment and
* TotalSegments parameters. For more information, see Parallel
* Scan in the Amazon DynamoDB Developer Guide.
*
*
* Scan uses eventually consistent reads when accessing the data in a table; therefore, the result set
* might not include the changes to data in the table immediately before the operation began. If you need a
* consistent copy of the data, as of the time that the Scan begins, you can set the
* ConsistentRead parameter to true.
*
*
*
* This is a variant of {@link #scan(software.amazon.awssdk.services.dynamodb.model.ScanRequest)} operation. The
* return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the forEach helper method
*
*
* {@code
* software.amazon.awssdk.services.dynamodb.paginators.ScanPublisher publisher = client.scanPaginator(request);
* CompletableFuture future = publisher.forEach(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.dynamodb.paginators.ScanPublisher publisher = client.scanPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.dynamodb.model.ScanResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Note: If you prefer to have control on service calls, use the
* {@link #scan(software.amazon.awssdk.services.dynamodb.model.ScanRequest)} operation.
*
*
* @param scanRequest
* Represents the input of a Scan operation.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ProvisionedThroughputExceededException Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your request is eventually successful, unless
* your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff.
* For more information, go to Error Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.Scan
* @see AWS API
* Documentation
*/
default ScanPublisher scanPaginator(ScanRequest scanRequest) {
throw new UnsupportedOperationException();
}
/**
*
* The Scan operation returns one or more items and item attributes by accessing every item in a table
* or a secondary index. To have DynamoDB return fewer items, you can provide a FilterExpression
* operation.
*
*
* If the total number of scanned items exceeds the maximum data set size limit of 1 MB, the scan stops and results
* are returned to the user as a LastEvaluatedKey value to continue the scan in a subsequent operation.
* The results also include the number of items exceeding the limit. A scan can result in no table data meeting the
* filter criteria.
*
*
* A single Scan operation will read up to the maximum number of items set (if using the
* Limit parameter) or a maximum of 1 MB of data and then apply any filtering to the results using
* FilterExpression. If LastEvaluatedKey is present in the response, you will need to
* paginate the result set. For more information, see Paginating the
* Results in the Amazon DynamoDB Developer Guide.
*
*
* Scan operations proceed sequentially; however, for faster performance on a large table or secondary
* index, applications can request a parallel Scan operation by providing the Segment and
* TotalSegments parameters. For more information, see Parallel
* Scan in the Amazon DynamoDB Developer Guide.
*
*
* Scan uses eventually consistent reads when accessing the data in a table; therefore, the result set
* might not include the changes to data in the table immediately before the operation began. If you need a
* consistent copy of the data, as of the time that the Scan begins, you can set the
* ConsistentRead parameter to true.
*
*
*
* This is a variant of {@link #scan(software.amazon.awssdk.services.dynamodb.model.ScanRequest)} operation. The
* return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the forEach helper method
*
*
* {@code
* software.amazon.awssdk.services.dynamodb.paginators.ScanPublisher publisher = client.scanPaginator(request);
* CompletableFuture future = publisher.forEach(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.dynamodb.paginators.ScanPublisher publisher = client.scanPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.dynamodb.model.ScanResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Note: If you prefer to have control on service calls, use the
* {@link #scan(software.amazon.awssdk.services.dynamodb.model.ScanRequest)} operation.
*
*
* This is a convenience which creates an instance of the {@link ScanRequest.Builder} avoiding the need to create
* one manually via {@link ScanRequest#builder()}
*
*
* @param scanRequest
* A {@link Consumer} that will call methods on {@link ScanInput.Builder} to create a request. Represents the
* input of a Scan operation.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ProvisionedThroughputExceededException Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your request is eventually successful, unless
* your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff.
* For more information, go to Error Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.Scan
* @see AWS API
* Documentation
*/
default ScanPublisher scanPaginator(Consumer scanRequest) {
return scanPaginator(ScanRequest.builder().applyMutation(scanRequest).build());
}
/**
*
* Associate a set of tags with an Amazon DynamoDB resource. You can then activate these user-defined tags so that
* they appear on the Billing and Cost Management console for cost allocation tracking. You can call TagResource up
* to 5 times per second, per account.
*
*
* For an overview on tagging DynamoDB resources, see Tagging for DynamoDB in
* the Amazon DynamoDB Developer Guide.
*
*
* @param tagResourceRequest
* @return A Java Future containing the result of the TagResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - ResourceInUseException The operation conflicts with the resource's availability. For example, you
* attempted to recreate an existing table, or tried to delete a table currently in the
*
CREATING state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.TagResource
* @see AWS API
* Documentation
*/
default CompletableFuture tagResource(TagResourceRequest tagResourceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Associate a set of tags with an Amazon DynamoDB resource. You can then activate these user-defined tags so that
* they appear on the Billing and Cost Management console for cost allocation tracking. You can call TagResource up
* to 5 times per second, per account.
*
*
* For an overview on tagging DynamoDB resources, see Tagging for DynamoDB in
* the Amazon DynamoDB Developer Guide.
*
*
*
* This is a convenience which creates an instance of the {@link TagResourceRequest.Builder} avoiding the need to
* create one manually via {@link TagResourceRequest#builder()}
*
*
* @param tagResourceRequest
* A {@link Consumer} that will call methods on {@link TagResourceInput.Builder} to create a request.
* @return A Java Future containing the result of the TagResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - ResourceInUseException The operation conflicts with the resource's availability. For example, you
* attempted to recreate an existing table, or tried to delete a table currently in the
*
CREATING state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.TagResource
* @see AWS API
* Documentation
*/
default CompletableFuture tagResource(Consumer tagResourceRequest) {
return tagResource(TagResourceRequest.builder().applyMutation(tagResourceRequest).build());
}
/**
*
* Removes the association of tags from an Amazon DynamoDB resource. You can call UntagResource up to 5 times per
* second, per account.
*
*
* For an overview on tagging DynamoDB resources, see Tagging for DynamoDB in
* the Amazon DynamoDB Developer Guide.
*
*
* @param untagResourceRequest
* @return A Java Future containing the result of the UntagResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - ResourceInUseException The operation conflicts with the resource's availability. For example, you
* attempted to recreate an existing table, or tried to delete a table currently in the
*
CREATING state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.UntagResource
* @see AWS API
* Documentation
*/
default CompletableFuture untagResource(UntagResourceRequest untagResourceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Removes the association of tags from an Amazon DynamoDB resource. You can call UntagResource up to 5 times per
* second, per account.
*
*
* For an overview on tagging DynamoDB resources, see Tagging for DynamoDB in
* the Amazon DynamoDB Developer Guide.
*
*
*
* This is a convenience which creates an instance of the {@link UntagResourceRequest.Builder} avoiding the need to
* create one manually via {@link UntagResourceRequest#builder()}
*
*
* @param untagResourceRequest
* A {@link Consumer} that will call methods on {@link UntagResourceInput.Builder} to create a request.
* @return A Java Future containing the result of the UntagResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - InternalServerErrorException An error occurred on the server side.
* - ResourceInUseException The operation conflicts with the resource's availability. For example, you
* attempted to recreate an existing table, or tried to delete a table currently in the
*
CREATING state.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.UntagResource
* @see AWS API
* Documentation
*/
default CompletableFuture untagResource(Consumer untagResourceRequest) {
return untagResource(UntagResourceRequest.builder().applyMutation(untagResourceRequest).build());
}
/**
*
* UpdateContinuousBackups enables or disables point in time recovery for the specified table. A
* successful UpdateContinuousBackups call returns the current
* ContinuousBackupsDescription. Continuous backups are ENABLED on all tables at table
* creation. If point in time recovery is enabled, PointInTimeRecoveryStatus will be set to ENABLED.
*
*
* Once continuous backups and point in time recovery are enabled, you can restore to any point in time within
* EarliestRestorableDateTime and LatestRestorableDateTime.
*
*
* LatestRestorableDateTime is typically 5 minutes before the current time. You can restore your table
* to any point in time during the last 35 days..
*
*
* @param updateContinuousBackupsRequest
* @return A Java Future containing the result of the UpdateContinuousBackups operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - TableNotFoundException A source table with the name
TableName does not currently exist
* within the subscriber's account.
* - ContinuousBackupsUnavailableException Backups have not yet been enabled for this table.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.UpdateContinuousBackups
* @see AWS API Documentation
*/
default CompletableFuture updateContinuousBackups(
UpdateContinuousBackupsRequest updateContinuousBackupsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* UpdateContinuousBackups enables or disables point in time recovery for the specified table. A
* successful UpdateContinuousBackups call returns the current
* ContinuousBackupsDescription. Continuous backups are ENABLED on all tables at table
* creation. If point in time recovery is enabled, PointInTimeRecoveryStatus will be set to ENABLED.
*
*
* Once continuous backups and point in time recovery are enabled, you can restore to any point in time within
* EarliestRestorableDateTime and LatestRestorableDateTime.
*
*
* LatestRestorableDateTime is typically 5 minutes before the current time. You can restore your table
* to any point in time during the last 35 days..
*
*
*
* This is a convenience which creates an instance of the {@link UpdateContinuousBackupsRequest.Builder} avoiding
* the need to create one manually via {@link UpdateContinuousBackupsRequest#builder()}
*
*
* @param updateContinuousBackupsRequest
* A {@link Consumer} that will call methods on {@link UpdateContinuousBackupsInput.Builder} to create a
* request.
* @return A Java Future containing the result of the UpdateContinuousBackups operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - TableNotFoundException A source table with the name
TableName does not currently exist
* within the subscriber's account.
* - ContinuousBackupsUnavailableException Backups have not yet been enabled for this table.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.UpdateContinuousBackups
* @see AWS API Documentation
*/
default CompletableFuture updateContinuousBackups(
Consumer updateContinuousBackupsRequest) {
return updateContinuousBackups(UpdateContinuousBackupsRequest.builder().applyMutation(updateContinuousBackupsRequest)
.build());
}
/**
*
* Adds or removes replicas in the specified global table. The global table must already exist to be able to use
* this operation. Any replica to be added must be empty, must have the same name as the global table, must have the
* same key schema, and must have DynamoDB Streams enabled and must have same provisioned and maximum write capacity
* units.
*
*
*
* Although you can use UpdateGlobalTable to add replicas and remove replicas in a single request, for
* simplicity we recommend that you issue separate requests for adding or removing replicas.
*
*
*
* If global secondary indexes are specified, then the following conditions must also be met:
*
*
* -
*
* The global secondary indexes must have the same name.
*
*
* -
*
* The global secondary indexes must have the same hash key and sort key (if present).
*
*
* -
*
* The global secondary indexes must have the same provisioned and maximum write capacity units.
*
*
*
*
* @param updateGlobalTableRequest
* @return A Java Future containing the result of the UpdateGlobalTable operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException An error occurred on the server side.
* - GlobalTableNotFoundException The specified global table does not exist.
* - ReplicaAlreadyExistsException The specified replica is already part of the global table.
* - ReplicaNotFoundException The specified replica is no longer part of the global table.
* - TableNotFoundException A source table with the name
TableName does not currently exist
* within the subscriber's account.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.UpdateGlobalTable
* @see AWS API
* Documentation
*/
default CompletableFuture updateGlobalTable(UpdateGlobalTableRequest updateGlobalTableRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Adds or removes replicas in the specified global table. The global table must already exist to be able to use
* this operation. Any replica to be added must be empty, must have the same name as the global table, must have the
* same key schema, and must have DynamoDB Streams enabled and must have same provisioned and maximum write capacity
* units.
*
*
*
* Although you can use UpdateGlobalTable to add replicas and remove replicas in a single request, for
* simplicity we recommend that you issue separate requests for adding or removing replicas.
*
*
*
* If global secondary indexes are specified, then the following conditions must also be met:
*
*
* -
*
* The global secondary indexes must have the same name.
*
*
* -
*
* The global secondary indexes must have the same hash key and sort key (if present).
*
*
* -
*
* The global secondary indexes must have the same provisioned and maximum write capacity units.
*
*
*
*
*
* This is a convenience which creates an instance of the {@link UpdateGlobalTableRequest.Builder} avoiding the need
* to create one manually via {@link UpdateGlobalTableRequest#builder()}
*
*
* @param updateGlobalTableRequest
* A {@link Consumer} that will call methods on {@link UpdateGlobalTableInput.Builder} to create a request.
* @return A Java Future containing the result of the UpdateGlobalTable operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - InternalServerErrorException An error occurred on the server side.
* - GlobalTableNotFoundException The specified global table does not exist.
* - ReplicaAlreadyExistsException The specified replica is already part of the global table.
* - ReplicaNotFoundException The specified replica is no longer part of the global table.
* - TableNotFoundException A source table with the name
TableName does not currently exist
* within the subscriber's account.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.UpdateGlobalTable
* @see AWS API
* Documentation
*/
default CompletableFuture updateGlobalTable(
Consumer updateGlobalTableRequest) {
return updateGlobalTable(UpdateGlobalTableRequest.builder().applyMutation(updateGlobalTableRequest).build());
}
/**
*
* Updates settings for a global table.
*
*
* @param updateGlobalTableSettingsRequest
* @return A Java Future containing the result of the UpdateGlobalTableSettings operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - GlobalTableNotFoundException The specified global table does not exist.
* - ReplicaNotFoundException The specified replica is no longer part of the global table.
* - IndexNotFoundException The operation tried to access a nonexistent index.
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - ResourceInUseException The operation conflicts with the resource's availability. For example, you
* attempted to recreate an existing table, or tried to delete a table currently in the
*
CREATING state.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.UpdateGlobalTableSettings
* @see AWS API Documentation
*/
default CompletableFuture updateGlobalTableSettings(
UpdateGlobalTableSettingsRequest updateGlobalTableSettingsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Updates settings for a global table.
*
*
*
* This is a convenience which creates an instance of the {@link UpdateGlobalTableSettingsRequest.Builder} avoiding
* the need to create one manually via {@link UpdateGlobalTableSettingsRequest#builder()}
*
*
* @param updateGlobalTableSettingsRequest
* A {@link Consumer} that will call methods on {@link UpdateGlobalTableSettingsInput.Builder} to create a
* request.
* @return A Java Future containing the result of the UpdateGlobalTableSettings operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - GlobalTableNotFoundException The specified global table does not exist.
* - ReplicaNotFoundException The specified replica is no longer part of the global table.
* - IndexNotFoundException The operation tried to access a nonexistent index.
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - ResourceInUseException The operation conflicts with the resource's availability. For example, you
* attempted to recreate an existing table, or tried to delete a table currently in the
*
CREATING state.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.UpdateGlobalTableSettings
* @see AWS API Documentation
*/
default CompletableFuture updateGlobalTableSettings(
Consumer updateGlobalTableSettingsRequest) {
return updateGlobalTableSettings(UpdateGlobalTableSettingsRequest.builder()
.applyMutation(updateGlobalTableSettingsRequest).build());
}
/**
*
* Edits an existing item's attributes, or adds a new item to the table if it does not already exist. You can put,
* delete, or add attribute values. You can also perform a conditional update on an existing item (insert a new
* attribute name-value pair if it doesn't exist, or replace an existing name-value pair if it has certain expected
* attribute values).
*
*
* You can also return the item's attribute values in the same UpdateItem operation using the
* ReturnValues parameter.
*
*
* @param updateItemRequest
* Represents the input of an UpdateItem operation.
* @return A Java Future containing the result of the UpdateItem operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ConditionalCheckFailedException A condition specified in the operation could not be evaluated.
* - ProvisionedThroughputExceededException Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your request is eventually successful, unless
* your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff.
* For more information, go to Error Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - ItemCollectionSizeLimitExceededException An item collection is too large. This exception is only
* returned for tables that have one or more local secondary indexes.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.UpdateItem
* @see AWS API
* Documentation
*/
default CompletableFuture updateItem(UpdateItemRequest updateItemRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Edits an existing item's attributes, or adds a new item to the table if it does not already exist. You can put,
* delete, or add attribute values. You can also perform a conditional update on an existing item (insert a new
* attribute name-value pair if it doesn't exist, or replace an existing name-value pair if it has certain expected
* attribute values).
*
*
* You can also return the item's attribute values in the same UpdateItem operation using the
* ReturnValues parameter.
*
*
*
* This is a convenience which creates an instance of the {@link UpdateItemRequest.Builder} avoiding the need to
* create one manually via {@link UpdateItemRequest#builder()}
*
*
* @param updateItemRequest
* A {@link Consumer} that will call methods on {@link UpdateItemInput.Builder} to create a request.
* Represents the input of an UpdateItem operation.
* @return A Java Future containing the result of the UpdateItem operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ConditionalCheckFailedException A condition specified in the operation could not be evaluated.
* - ProvisionedThroughputExceededException Your request rate is too high. The AWS SDKs for DynamoDB
* automatically retry requests that receive this exception. Your request is eventually successful, unless
* your retry queue is too large to finish. Reduce the frequency of requests and use exponential backoff.
* For more information, go to Error Retries and Exponential Backoff in the Amazon DynamoDB Developer Guide.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - ItemCollectionSizeLimitExceededException An item collection is too large. This exception is only
* returned for tables that have one or more local secondary indexes.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.UpdateItem
* @see AWS API
* Documentation
*/
default CompletableFuture updateItem(Consumer updateItemRequest) {
return updateItem(UpdateItemRequest.builder().applyMutation(updateItemRequest).build());
}
/**
*
* Modifies the provisioned throughput settings, global secondary indexes, or DynamoDB Streams settings for a given
* table.
*
*
* You can only perform one of the following operations at once:
*
*
* -
*
* Modify the provisioned throughput settings of the table.
*
*
* -
*
* Enable or disable Streams on the table.
*
*
* -
*
* Remove a global secondary index from the table.
*
*
* -
*
* Create a new global secondary index on the table. Once the index begins backfilling, you can use
* UpdateTable to perform other operations.
*
*
*
*
* UpdateTable is an asynchronous operation; while it is executing, the table status changes from
* ACTIVE to UPDATING. While it is UPDATING, you cannot issue another
* UpdateTable request. When the table returns to the ACTIVE state, the
* UpdateTable operation is complete.
*
*
* @param updateTableRequest
* Represents the input of an UpdateTable operation.
* @return A Java Future containing the result of the UpdateTable operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ResourceInUseException The operation conflicts with the resource's availability. For example, you
* attempted to recreate an existing table, or tried to delete a table currently in the
*
CREATING state.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.UpdateTable
* @see AWS API
* Documentation
*/
default CompletableFuture updateTable(UpdateTableRequest updateTableRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Modifies the provisioned throughput settings, global secondary indexes, or DynamoDB Streams settings for a given
* table.
*
*
* You can only perform one of the following operations at once:
*
*
* -
*
* Modify the provisioned throughput settings of the table.
*
*
* -
*
* Enable or disable Streams on the table.
*
*
* -
*
* Remove a global secondary index from the table.
*
*
* -
*
* Create a new global secondary index on the table. Once the index begins backfilling, you can use
* UpdateTable to perform other operations.
*
*
*
*
* UpdateTable is an asynchronous operation; while it is executing, the table status changes from
* ACTIVE to UPDATING. While it is UPDATING, you cannot issue another
* UpdateTable request. When the table returns to the ACTIVE state, the
* UpdateTable operation is complete.
*
*
*
* This is a convenience which creates an instance of the {@link UpdateTableRequest.Builder} avoiding the need to
* create one manually via {@link UpdateTableRequest#builder()}
*
*
* @param updateTableRequest
* A {@link Consumer} that will call methods on {@link UpdateTableInput.Builder} to create a request.
* Represents the input of an UpdateTable operation.
* @return A Java Future containing the result of the UpdateTable operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ResourceInUseException The operation conflicts with the resource's availability. For example, you
* attempted to recreate an existing table, or tried to delete a table currently in the
*
CREATING state.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.UpdateTable
* @see AWS API
* Documentation
*/
default CompletableFuture updateTable(Consumer updateTableRequest) {
return updateTable(UpdateTableRequest.builder().applyMutation(updateTableRequest).build());
}
/**
*
* The UpdateTimeToLive method will enable or disable TTL for the specified table. A successful
* UpdateTimeToLive call returns the current TimeToLiveSpecification; it may take up to
* one hour for the change to fully process. Any additional UpdateTimeToLive calls for the same table
* during this one hour duration result in a ValidationException.
*
*
* TTL compares the current time in epoch time format to the time stored in the TTL attribute of an item. If the
* epoch time value stored in the attribute is less than the current time, the item is marked as expired and
* subsequently deleted.
*
*
*
* The epoch time format is the number of seconds elapsed since 12:00:00 AM January 1st, 1970 UTC.
*
*
*
* DynamoDB deletes expired items on a best-effort basis to ensure availability of throughput for other data
* operations.
*
*
*
* DynamoDB typically deletes expired items within two days of expiration. The exact duration within which an item
* gets deleted after expiration is specific to the nature of the workload. Items that have expired and not been
* deleted will still show up in reads, queries, and scans.
*
*
*
* As items are deleted, they are removed from any Local Secondary Index and Global Secondary Index immediately in
* the same eventually consistent way as a standard delete operation.
*
*
* For more information, see Time
* To Live in the Amazon DynamoDB Developer Guide.
*
*
* @param updateTimeToLiveRequest
* Represents the input of an UpdateTimeToLive operation.
* @return A Java Future containing the result of the UpdateTimeToLive operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ResourceInUseException The operation conflicts with the resource's availability. For example, you
* attempted to recreate an existing table, or tried to delete a table currently in the
*
CREATING state.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.UpdateTimeToLive
* @see AWS API
* Documentation
*/
default CompletableFuture updateTimeToLive(UpdateTimeToLiveRequest updateTimeToLiveRequest) {
throw new UnsupportedOperationException();
}
/**
*
* The UpdateTimeToLive method will enable or disable TTL for the specified table. A successful
* UpdateTimeToLive call returns the current TimeToLiveSpecification; it may take up to
* one hour for the change to fully process. Any additional UpdateTimeToLive calls for the same table
* during this one hour duration result in a ValidationException.
*
*
* TTL compares the current time in epoch time format to the time stored in the TTL attribute of an item. If the
* epoch time value stored in the attribute is less than the current time, the item is marked as expired and
* subsequently deleted.
*
*
*
* The epoch time format is the number of seconds elapsed since 12:00:00 AM January 1st, 1970 UTC.
*
*
*
* DynamoDB deletes expired items on a best-effort basis to ensure availability of throughput for other data
* operations.
*
*
*
* DynamoDB typically deletes expired items within two days of expiration. The exact duration within which an item
* gets deleted after expiration is specific to the nature of the workload. Items that have expired and not been
* deleted will still show up in reads, queries, and scans.
*
*
*
* As items are deleted, they are removed from any Local Secondary Index and Global Secondary Index immediately in
* the same eventually consistent way as a standard delete operation.
*
*
* For more information, see Time
* To Live in the Amazon DynamoDB Developer Guide.
*
*
*
* This is a convenience which creates an instance of the {@link UpdateTimeToLiveRequest.Builder} avoiding the need
* to create one manually via {@link UpdateTimeToLiveRequest#builder()}
*
*
* @param updateTimeToLiveRequest
* A {@link Consumer} that will call methods on {@link UpdateTimeToLiveInput.Builder} to create a request.
* Represents the input of an UpdateTimeToLive operation.
* @return A Java Future containing the result of the UpdateTimeToLive operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions.
*
* - ResourceInUseException The operation conflicts with the resource's availability. For example, you
* attempted to recreate an existing table, or tried to delete a table currently in the
*
CREATING state.
* - ResourceNotFoundException The operation tried to access a nonexistent table or index. The resource
* might not be specified correctly, or its status might not be
ACTIVE.
* - LimitExceededException Up to 50
CreateBackup operations are allowed per second, per
* account. There is no limit to the number of daily on-demand backups that can be taken.
*
* Up to 10 simultaneous table operations are allowed per account. These operations include
* CreateTable, UpdateTable, DeleteTable,
* UpdateTimeToLive, RestoreTableFromBackup, and
* RestoreTableToPointInTime.
*
*
* For tables with secondary indexes, only one of those tables can be in the CREATING state at
* any point in time. Do not attempt to create more than one such table simultaneously.
*
*
* The total limit of tables in the ACTIVE state is 250.
* - InternalServerErrorException An error occurred on the server side.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - DynamoDbException Base class for all service exceptions. Unknown exceptions will be thrown as an
* instance of this type.
*
* @sample DynamoDbAsyncClient.UpdateTimeToLive
* @see AWS API
* Documentation
*/
default CompletableFuture updateTimeToLive(
Consumer updateTimeToLiveRequest) {
return updateTimeToLive(UpdateTimeToLiveRequest.builder().applyMutation(updateTimeToLiveRequest).build());
}
}