public final class DefaultDynamoDbEnhancedAsyncClient extends Object implements DynamoDbEnhancedAsyncClient
| Modifier and Type | Class and Description |
|---|---|
static class |
DefaultDynamoDbEnhancedAsyncClient.Builder |
| Modifier and Type | Method and Description |
|---|---|
BatchGetResultPagePublisher |
batchGetItem(BatchGetItemEnhancedRequest request)
Retrieves items from one or more tables by their primary keys, see
Key. |
BatchGetResultPagePublisher |
batchGetItem(Consumer<BatchGetItemEnhancedRequest.Builder> requestConsumer)
Retrieves items from one or more tables by their primary keys, see
Key. |
CompletableFuture<BatchWriteResult> |
batchWriteItem(BatchWriteItemEnhancedRequest request)
Puts and/or deletes multiple items in one or more tables.
|
CompletableFuture<BatchWriteResult> |
batchWriteItem(Consumer<BatchWriteItemEnhancedRequest.Builder> requestConsumer)
Puts and/or deletes multiple items in one or more tables.
|
static DefaultDynamoDbEnhancedAsyncClient.Builder |
builder()
Creates a default builder for
DynamoDbEnhancedAsyncClient. |
DynamoDbAsyncClient |
dynamoDbAsyncClient() |
boolean |
equals(Object o) |
int |
hashCode() |
DynamoDbEnhancedClientExtension |
mapperExtension() |
<T> DefaultDynamoDbAsyncTable<T> |
table(String tableName,
TableSchema<T> tableSchema)
Returns a mapped table that can be used to execute commands that work with mapped items against that table.
|
DefaultDynamoDbEnhancedAsyncClient.Builder |
toBuilder() |
CompletableFuture<List<Document>> |
transactGetItems(Consumer<TransactGetItemsEnhancedRequest.Builder> requestConsumer)
Retrieves multiple items from one or more tables in a single atomic transaction.
|
CompletableFuture<List<Document>> |
transactGetItems(TransactGetItemsEnhancedRequest request)
Retrieves multiple items from one or more tables in a single atomic transaction.
|
CompletableFuture<Void> |
transactWriteItems(Consumer<TransactWriteItemsEnhancedRequest.Builder> requestConsumer)
Writes and/or modifies multiple items from one or more tables in a single atomic transaction.
|
CompletableFuture<Void> |
transactWriteItems(TransactWriteItemsEnhancedRequest request)
Writes and/or modifies multiple items from one or more tables in a single atomic transaction.
|
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, waitcreatepublic static DefaultDynamoDbEnhancedAsyncClient.Builder builder()
DynamoDbEnhancedAsyncClientDynamoDbEnhancedAsyncClient.builder in interface DynamoDbEnhancedAsyncClientpublic <T> DefaultDynamoDbAsyncTable<T> table(String tableName, TableSchema<T> tableSchema)
DynamoDbEnhancedAsyncClienttable in interface DynamoDbEnhancedAsyncClientT - THe modelled object type being mapped to this table.tableName - The name of the physical table persisted by DynamoDb.tableSchema - A TableSchema that maps the table to a modelled object.DynamoDbAsyncTable object that can be used to execute table operations against.public BatchGetResultPagePublisher batchGetItem(BatchGetItemEnhancedRequest request)
DynamoDbEnhancedAsyncClientKey. BatchGetItem is a composite operation
where the request contains one batch of GetItemEnhancedRequest per targeted table.
The operation makes several calls to the database; each time you iterate over the result to retrieve a page,
a call is made for the items on that page.
The additional configuration parameters that the enhanced client supports are defined
in the BatchGetItemEnhancedRequest.
Partial results. A single call to DynamoDb has restraints on how much data can be retrieved. If those limits are exceeded, the call yields a partial result. This may also be the case if provisional throughput is exceeded or there is an internal DynamoDb processing failure. The operation automatically retries any unprocessed keys returned from DynamoDb in subsequent calls for pages.
This operation calls the low-level DynamoDbAsyncClient.batchGetItemPaginator(software.amazon.awssdk.services.dynamodb.model.BatchGetItemRequest) operation. Consult the
BatchGetItem documentation for further details and constraints as well as current limits of data retrieval.
Example:
BatchGetResultPagePublisher publisher = enhancedClient.batchGetItem(
BatchGetItemEnhancedRequest.builder()
.readBatches(ReadBatch.builder(FirstItem.class)
.mappedTableResource(firstItemTable)
.addGetItem(GetItemEnhancedRequest.builder().key(key1).build())
.addGetItem(GetItemEnhancedRequest.builder().key(key2).build())
.build(),
ReadBatch.builder(SecondItem.class)
.mappedTableResource(secondItemTable)
.addGetItem(GetItemEnhancedRequest.builder().key(key3).build())
.build())
.build());
The returned BatchGetResultPagePublisher can be subscribed to request a stream of BatchGetResultPages
or a stream of flattened results belonging to the supplied table across all pages.
1) Subscribing to BatchGetResultPages
publisher.subscribe(page -> {
page.resultsForTable(firstItemTable).forEach(item -> System.out.println(item));
page.resultsForTable(secondItemTable).forEach(item -> System.out.println(item));
});
2) Subscribing to results across all pages
publisher.resultsForTable(firstItemTable).subscribe(item -> System.out.println(item));
publisher.resultsForTable(secondItemTable).subscribe(item -> System.out.println(item));
batchGetItem in interface DynamoDbEnhancedAsyncClientrequest - A BatchGetItemEnhancedRequest containing keys grouped by tables.SdkPublisher with paginated results of type BatchGetResultPage.DynamoDbEnhancedAsyncClient.batchGetItem(Consumer),
DynamoDbAsyncClient.batchGetItemPaginator(software.amazon.awssdk.services.dynamodb.model.BatchGetItemRequest)public BatchGetResultPagePublisher batchGetItem(Consumer<BatchGetItemEnhancedRequest.Builder> requestConsumer)
DynamoDbEnhancedAsyncClientKey. BatchGetItem is a composite operation
where the request contains one batch of GetItemEnhancedRequest per targeted table.
The operation makes several calls to the database; each time you iterate over the result to retrieve a page,
a call is made for the items on that page.
Note: This is a convenience method that creates an instance of the request builder avoiding the need to create one
manually via BatchGetItemEnhancedRequest.builder().
Example:
BatchGetResultPagePublisher batchResults = enhancedClient.batchGetItem(r -> r.addReadBatches(
ReadBatch.builder(FirstItem.class)
.mappedTableResource(firstItemTable)
.addGetItem(i -> i.key(key1))
.addGetItem(i -> i.key(key2))
.build(),
ReadBatch.builder(SecondItem.class)
.mappedTableResource(secondItemTable)
.addGetItem(i -> i.key(key3))
.build()));
batchGetItem in interface DynamoDbEnhancedAsyncClientrequestConsumer - a Consumer of BatchGetItemEnhancedRequest.Builder containing keys grouped by tables.SdkPublisher with paginated results of type BatchGetResultPage.DynamoDbEnhancedAsyncClient.batchGetItem(BatchGetItemEnhancedRequest),
DynamoDbAsyncClient.batchGetItem(software.amazon.awssdk.services.dynamodb.model.BatchGetItemRequest)public CompletableFuture<BatchWriteResult> batchWriteItem(BatchWriteItemEnhancedRequest request)
DynamoDbEnhancedAsyncClientPutItemEnhancedRequest and DeleteItemEnhancedRequest per targeted table.
The additional configuration parameters that the enhanced client supports are defined
in the BatchWriteItemEnhancedRequest.
Note: BatchWriteItem cannot update items. Instead, use the individual updateItem operation
DynamoDbAsyncTable.updateItem(UpdateItemEnhancedRequest).
Partial updates
Each delete or put call is atomic, but the operation as a whole is not.
If individual operations fail due to exceeded provisional throughput internal DynamoDb processing failures,
the failed requests can be retrieved through the result, see BatchWriteResult.
There are some conditions that cause the whole batch operation to fail. These include non-existing tables, erroneously defined primary key attributes, attempting to put and delete the same item as well as referring more than once to the same hash and range (sort) key.
This operation calls the low-level DynamoDB API BatchWriteItem operation. Consult the BatchWriteItem documentation for further details and constraints, current limits of data to write and/or delete, how to handle partial updates and retries and under which conditions the operation will fail.
Example:
BatchWriteResult batchResult = enhancedClient.batchWriteItem(
BatchWriteItemEnhancedRequest.builder()
.writeBatches(WriteBatch.builder(FirstItem.class)
.mappedTableResource(firstItemTable)
.addPutItem(PutItemEnhancedRequest.builder().item(item1).build())
.addDeleteItem(DeleteItemEnhancedRequest.builder()
.key(key2)
.build())
.build(),
WriteBatch.builder(SecondItem.class)
.mappedTableResource(secondItemTable)
.addPutItem(PutItemEnhancedRequest.builder().item(item3).build())
.build())
.build()).join();
batchWriteItem in interface DynamoDbEnhancedAsyncClientrequest - A BatchWriteItemEnhancedRequest containing keys and items grouped by tables.CompletableFuture of BatchWriteResult, containing any unprocessed requests.public CompletableFuture<BatchWriteResult> batchWriteItem(Consumer<BatchWriteItemEnhancedRequest.Builder> requestConsumer)
DynamoDbEnhancedAsyncClientPutItemEnhancedRequest and DeleteItemEnhancedRequest per targeted table.
The additional configuration parameters that the enhanced client supports are defined
in the BatchWriteItemEnhancedRequest.
Note: BatchWriteItem cannot update items. Instead, use the individual updateItem operation
DynamoDbAsyncTable.updateItem(software.amazon.awssdk.enhanced.dynamodb.model.UpdateItemEnhancedRequest<T>)}.
Partial updates
Each delete or put call is atomic, but the operation as a whole is not.
If individual operations fail due to exceeded provisional throughput internal DynamoDb processing failures,
the failed requests can be retrieved through the result, see BatchWriteResult.
There are some conditions that cause the whole batch operation to fail. These include non-existing tables, erroneously defined primary key attributes, attempting to put and delete the same item as well as referring more than once to the same hash and range (sort) key.
This operation calls the low-level DynamoDB API BatchWriteItem operation. Consult the BatchWriteItem documentation for further details and constraints, current limits of data to write and/or delete, how to handle partial updates and retries and under which conditions the operation will fail.
Note: This is a convenience method that creates an instance of the request builder avoiding the need to create one
manually via BatchWriteItemEnhancedRequest.builder().
Example:
BatchWriteResult batchResult = enhancedClient.batchWriteItem(r -> r.writeBatches(
WriteBatch.builder(FirstItem.class)
.mappedTableResource(firstItemTable)
.addPutItem(i -> i.item(item1))
.addDeleteItem(i -> i.key(key2))
.build(),
WriteBatch.builder(SecondItem.class)
.mappedTableResource(secondItemTable)
.addPutItem(i -> i.item(item3))
.build())).join();
batchWriteItem in interface DynamoDbEnhancedAsyncClientrequestConsumer - a Consumer of BatchWriteItemEnhancedRequest containing keys and items grouped by
tables.CompletableFuture of BatchWriteResult, containing any unprocessed requests.public CompletableFuture<List<Document>> transactGetItems(TransactGetItemsEnhancedRequest request)
DynamoDbEnhancedAsyncClientGetItemEnhancedRequest.
The additional configuration parameters that the enhanced client supports are defined
in the TransactGetItemsEnhancedRequest.
DynamoDb will reject a call to TransactGetItems if the call exceeds limits such as provisioned throughput or allowed size of items, if the request contains errors or if there are conflicting operations accessing the same item, for instance updating and reading at the same time.
This operation calls the low-level DynamoDB API TransactGetItems operation. Consult the TransactGetItems documentation for further details and constraints.
Examples:
List<TransactGetResultPage> results = enhancedClient.transactGetItems(
TransactGetItemsEnhancedRequest.builder()
.addGetItem(firstItemTable, GetItemEnhancedRequest.builder().key(key1).build())
.addGetItem(firstItemTable, GetItemEnhancedRequest.builder().key(key2).build())
.addGetItem(firstItemTable, GetItemEnhancedRequest.builder().key(key3).build())
.addGetItem(secondItemTable, GetItemEnhancedRequest.builder().key(key4).build())
.build()).join();
transactGetItems in interface DynamoDbEnhancedAsyncClientrequest - A TransactGetItemsEnhancedRequest containing keys with table references.CompletableFuture containing a list of Document with the results.public CompletableFuture<List<Document>> transactGetItems(Consumer<TransactGetItemsEnhancedRequest.Builder> requestConsumer)
DynamoDbEnhancedAsyncClientGetItemEnhancedRequest.
The additional configuration parameters that the enhanced client supports are defined
in the TransactGetItemsEnhancedRequest.
DynamoDb will reject a call to TransactGetItems if the call exceeds limits such as provisioned throughput or allowed size of items, if the request contains errors or if there are conflicting operations accessing the same item, for instance updating and reading at the same time.
This operation calls the low-level DynamoDB API TransactGetItems operation. Consult the TransactGetItems documentation for further details and constraints.
Note: This is a convenience method that creates an instance of the request builder avoiding the need to create one
manually via TransactGetItemsEnhancedRequest.builder().
Examples:
List<TransactGetResultPage> results = = enhancedClient.transactGetItems(
r -> r.addGetItem(firstItemTable, i -> i.key(k -> k.partitionValue(0)))
.addGetItem(firstItemTable, i -> i.key(k -> k.partitionValue(1)))
.addGetItem(firstItemTable, i -> i.key(k -> k.partitionValue(2)))
.addGetItem(secondItemTable, i -> i.key(k -> k.partitionValue(0)))).join();
transactGetItems in interface DynamoDbEnhancedAsyncClientrequestConsumer - a Consumer of TransactGetItemsEnhancedRequest containing keys with table references.CompletableFuture containing a list of Document with the results.public CompletableFuture<Void> transactWriteItems(TransactWriteItemsEnhancedRequest request)
DynamoDbEnhancedAsyncClientConditionCheckDeleteItemEnhancedRequestPutItemEnhancedRequestUpdateItemEnhancedRequest
The additional configuration parameters that the enhanced client supports are defined
in the TransactWriteItemsEnhancedRequest.
DynamoDb will reject a call to TransactWriteItems if the call exceeds limits such as provisioned throughput or allowed size of items, if the request contains errors or if there are conflicting operations accessing the same item. If the request contains condition checks that aren't met, this will also cause rejection.
This operation calls the low-level DynamoDB API TransactWriteItems operation. Consult the TransactWriteItems documentation for further details and constraints, current limits of data to write and/or delete and under which conditions the operation will fail.
Example:
enhancedClient.transactWriteItems(
TransactWriteItemsEnhancedRequest.builder()
.addPutItem(firstItemTable, PutItemEnhancedRequest.builder().item(item1).build())
.addDeleteItem(firstItemTable, DeleteItemEnhancedRequest.builder().key(key2).build())
.addConditionCheck(firstItemTable,
ConditionCheck.builder()
.key(key3)
.conditionExpression(conditionExpression)
.build())
.addUpdateItem(secondItemTable,
UpdateItemEnhancedRequest.builder().item(item4).build())
.build()).join();
transactWriteItems in interface DynamoDbEnhancedAsyncClientrequest - A BatchWriteItemEnhancedRequest containing keys grouped by tables.CompletableFuture of Void.public CompletableFuture<Void> transactWriteItems(Consumer<TransactWriteItemsEnhancedRequest.Builder> requestConsumer)
DynamoDbEnhancedAsyncClientConditionCheckDeleteItemEnhancedRequestPutItemEnhancedRequestUpdateItemEnhancedRequest
The additional configuration parameters that the enhanced client supports are defined
in the TransactWriteItemsEnhancedRequest.
DynamoDb will reject a call to TransactWriteItems if the call exceeds limits such as provisioned throughput or allowed size of items, if the request contains errors or if there are conflicting operations accessing the same item. If the request contains condition checks that aren't met, this will also cause rejection.
This operation calls the low-level DynamoDB API TransactWriteItems operation. Consult the TransactWriteItems documentation for further details and constraints, current limits of data to write and/or delete and under which conditions the operation will fail.
Note: This is a convenience method that creates an instance of the request builder avoiding the need to create one
manually via TransactWriteItemsEnhancedRequest.builder().
Example:
enhancedClient.transactWriteItems(r -> r.addPutItem(firstItemTable, i -> i.item(item1))
.addDeleteItem(firstItemTable, i -> i.key(k -> k.partitionValue(2)))
.addConditionCheck(firstItemTable, i -> i.key(key3)
.conditionExpression(conditionExpression))
.addUpdateItem(secondItemTable, i -> i.item(item4))).join();
transactWriteItems in interface DynamoDbEnhancedAsyncClientrequestConsumer - a Consumer of TransactWriteItemsEnhancedRequest containing keys and items grouped by
tables.CompletableFuture of Void.public DynamoDbAsyncClient dynamoDbAsyncClient()
public DynamoDbEnhancedClientExtension mapperExtension()
public DefaultDynamoDbEnhancedAsyncClient.Builder toBuilder()
Copyright © 2022. All rights reserved.