DefaultDynamoDbTable (AWS Java SDK :: DynamoDB :: Enhanced Client 2.17.275 API)

java.lang.Object
- software.amazon.awssdk.enhanced.dynamodb.internal.client.DefaultDynamoDbTable<T>

All Implemented Interfaces:: DynamoDbTable<T>, MappedTableResource<T>

public class DefaultDynamoDbTable<T>
extends Object
implements DynamoDbTable<T>

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`createTable()` Creates a new table in DynamoDb with the name and schema already defined for this DynamoDbTable.
`void`	`createTable(Consumer<CreateTableEnhancedRequest.Builder> requestConsumer)` Creates a new table in DynamoDb with the name and schema already defined for this DynamoDbTable together with additional parameters specified in the supplied request object, `CreateTableEnhancedRequest`.
`void`	`createTable(CreateTableEnhancedRequest request)` Creates a new table in DynamoDb with the name and schema already defined for this DynamoDbTable together with additional parameters specified in the supplied request object, `CreateTableEnhancedRequest`.
`T`	`deleteItem(Consumer<DeleteItemEnhancedRequest.Builder> requestConsumer)` Deletes a single item from the mapped table using a supplied primary `Key`.
`T`	`deleteItem(DeleteItemEnhancedRequest request)` Deletes a single item from the mapped table using a supplied primary `Key`.
`T`	`deleteItem(Key key)` Deletes a single item from the mapped table using a supplied primary `Key`.
`T`	`deleteItem(T keyItem)` Deletes a single item from the mapped table using just the key of a supplied modelled 'key item' object.
`DeleteItemEnhancedResponse<T>`	`deleteItemWithResponse(Consumer<DeleteItemEnhancedRequest.Builder> requestConsumer)` Deletes a single item from the mapped table using a supplied primary `Key`.
`DeleteItemEnhancedResponse<T>`	`deleteItemWithResponse(DeleteItemEnhancedRequest request)` Deletes a single item from the mapped table using a supplied primary `Key`.
`void`	`deleteTable()` Deletes a table in DynamoDb with the name and schema already defined for this DynamoDbTable.
`DescribeTableEnhancedResponse`	`describeTable()` Describes a table in DynamoDb with the name defined for this {@link DynamoDbTable).
`DynamoDbClient`	`dynamoDbClient()`
`boolean`	`equals(Object o)`
`T`	`getItem(Consumer<GetItemEnhancedRequest.Builder> requestConsumer)` Retrieves a single item from the mapped table using a supplied primary `Key`.
`T`	`getItem(GetItemEnhancedRequest request)` Retrieves a single item from the mapped table using a supplied primary `Key`.
`T`	`getItem(Key key)` Retrieves a single item from the mapped table using a supplied primary `Key`.
`T`	`getItem(T keyItem)` Retrieves a single item from the mapped table using just the key of a supplied modelled 'key item'.
`int`	`hashCode()`
`DefaultDynamoDbIndex<T>`	`index(String indexName)` Returns a mapped index that can be used to execute commands against a secondary index belonging to the table being mapped by this object.
`Key`	`keyFrom(T item)` Creates a `Key` object from a modelled item.
`DynamoDbEnhancedClientExtension`	`mapperExtension()` Gets the `DynamoDbEnhancedClientExtension` associated with this mapped resource.
`void`	`putItem(Consumer<PutItemEnhancedRequest.Builder<T>> requestConsumer)` Puts a single item in the mapped table.
`void`	`putItem(PutItemEnhancedRequest<T> request)` Puts a single item in the mapped table.
`void`	`putItem(T item)` Puts a single item in the mapped table.
`PutItemEnhancedResponse<T>`	`putItemWithResponse(Consumer<PutItemEnhancedRequest.Builder<T>> requestConsumer)` Puts a single item in the mapped table.
`PutItemEnhancedResponse<T>`	`putItemWithResponse(PutItemEnhancedRequest<T> request)` Puts a single item in the mapped table.
`PageIterable<T>`	`query(Consumer<QueryEnhancedRequest.Builder> requestConsumer)` This is a convenience method that creates an instance of the request builder avoiding the need to create one manually via `QueryEnhancedRequest.builder()`.
`PageIterable<T>`	`query(QueryConditional queryConditional)` Executes a query against the primary index of the table using a `QueryConditional` expression to retrieve a list of items matching the given conditions.
`PageIterable<T>`	`query(QueryEnhancedRequest request)` Executes a query against the primary index of the table using a `QueryConditional` expression to retrieve a list of items matching the given conditions.
`PageIterable<T>`	`scan()` Scans the table and retrieves all items using default settings.
`PageIterable<T>`	`scan(Consumer<ScanEnhancedRequest.Builder> requestConsumer)` This is a convenience method that creates an instance of the request builder avoiding the need to create one manually via `ScanEnhancedRequest.builder()`.
`PageIterable<T>`	`scan(ScanEnhancedRequest request)` Scans the table and retrieves all items.
`String`	`tableName()` Gets the physical table name that operations performed by this object will be executed against.
`TableSchema<T>`	`tableSchema()` Gets the `TableSchema` object that this mapped table was built with.
`T`	`updateItem(Consumer<UpdateItemEnhancedRequest.Builder<T>> requestConsumer)` Updates an item in the mapped table, or adds it if it doesn't exist.
`T`	`updateItem(T item)` Updates an item in the mapped table, or adds it if it doesn't exist.
`T`	`updateItem(UpdateItemEnhancedRequest<T> request)` Updates an item in the mapped table, or adds it if it doesn't exist.
`UpdateItemEnhancedResponse<T>`	`updateItemWithResponse(Consumer<UpdateItemEnhancedRequest.Builder<T>> requestConsumer)` Updates an item in the mapped table, or adds it if it doesn't exist.
`UpdateItemEnhancedResponse<T>`	`updateItemWithResponse(UpdateItemEnhancedRequest<T> request)` Updates an item in the mapped table, or adds it if it doesn't exist.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - mapperExtension
```
public DynamoDbEnhancedClientExtension mapperExtension()
```
    Description copied from interface: MappedTableResource
    
    Gets the DynamoDbEnhancedClientExtension associated with this mapped resource.
    
    Specified by:
    
    mapperExtension in interface MappedTableResource<T>
    
    Returns:
    
    The DynamoDbEnhancedClientExtension associated with this mapped resource.
  - tableSchema
```
public TableSchema<T> tableSchema()
```
    Description copied from interface: MappedTableResource
    
    Gets the TableSchema object that this mapped table was built with.
    
    Specified by:
    
    tableSchema in interface MappedTableResource<T>
    
    Returns:
    
    The TableSchema object for this mapped table.
  - dynamoDbClient
```
public DynamoDbClient dynamoDbClient()
```
  - tableName
```
public String tableName()
```
    Description copied from interface: MappedTableResource
    
    Gets the physical table name that operations performed by this object will be executed against.
    
    Specified by:
    
    tableName in interface MappedTableResource<T>
    
    Returns:
    
    The physical table name.
  - index
```
public DefaultDynamoDbIndex<T> index(String indexName)
```
    Description copied from interface: DynamoDbTable
    
    Returns a mapped index that can be used to execute commands against a secondary index belonging to the table being mapped by this object. Note that only a subset of the commands that work against a table will work against a secondary index.
    
    Specified by:
    
    index in interface DynamoDbTable<T>
    
    Parameters:
    
    indexName - The name of the secondary index to build the command interface for.
    
    Returns:
    
    A DynamoDbIndex object that can be used to execute database commands against.
  - createTable
```
public void createTable(CreateTableEnhancedRequest request)
```
    Description copied from interface: DynamoDbTable
    Creates a new table in DynamoDb with the name and schema already defined for this DynamoDbTable together with additional parameters specified in the supplied request object, CreateTableEnhancedRequest.
    Use DynamoDbEnhancedClient.table(String, TableSchema) to define the mapped table resource.
    This operation calls the low-level DynamoDB API CreateTable operation. Note that this is an asynchronous operation and that the table may not immediately be available for writes and reads. You can use DynamoDbWaiter.waitUntilTableExists(DescribeTableRequest) to wait for the resource to be ready.
    Example:
```
 

 ProvisionedThroughput provisionedThroughput = ProvisionedThroughput.builder()
                                                                    .readCapacityUnits(50L)
                                                                    .writeCapacityUnits(50L)
                                                                    .build();
 mappedTable.createTable(CreateTableEnhancedRequest.builder()
                                                   .provisionedThroughput(provisionedThroughput)
                                                   .build());

 dynamoDbClient.waiter().waitUntilTableExists(b -> b.tableName(tableName));
 
 
```
    Specified by:
    
    createTable in interface DynamoDbTable<T>
    
    Parameters:
    
    request - A CreateTableEnhancedRequest containing optional parameters for table creation.
  - createTable
```
public void createTable(Consumer<CreateTableEnhancedRequest.Builder> requestConsumer)
```
    Description copied from interface: DynamoDbTable
    Creates a new table in DynamoDb with the name and schema already defined for this DynamoDbTable together with additional parameters specified in the supplied request object, CreateTableEnhancedRequest.
    Use DynamoDbEnhancedClient.table(String, TableSchema) to define the mapped table resource.
    This operation calls the low-level DynamoDB API CreateTable operation. Note that this is an asynchronous operation and that the table may not immediately be available for writes and reads. You can use DynamoDbWaiter.waitUntilTableExists(DescribeTableRequest) to wait for the resource to be ready.
    Note: This is a convenience method that creates an instance of the request builder avoiding the need to create one manually via CreateTableEnhancedRequest.builder().
    Example:
```
 

 ProvisionedThroughput provisionedThroughput = ProvisionedThroughput.builder()
                                                                    .readCapacityUnits(50L)
                                                                    .writeCapacityUnits(50L)
                                                                    .build();
 mappedTable.createTable(r -> r.provisionedThroughput(provisionedThroughput));
 dynamoDbClient.waiter().waitUntilTableExists(b -> b.tableName(tableName));
 
 
```
    Specified by:
    
    createTable in interface DynamoDbTable<T>
    
    Parameters:
    
    requestConsumer - A Consumer of CreateTableEnhancedRequest.Builder containing optional parameters for table creation.
  - createTable
```
public void createTable()
```
    Description copied from interface: DynamoDbTable
    Creates a new table in DynamoDb with the name and schema already defined for this DynamoDbTable.
    Use DynamoDbEnhancedClient.table(String, TableSchema) to define the mapped table resource.
    This operation calls the low-level DynamoDB API CreateTable operation. Note that this is an asynchronous operation and that the table may not immediately be available for writes and reads. You can use DynamoDbWaiter.waitUntilTableExists(DescribeTableRequest) to wait for the resource to be ready.
    Example:
```
 

 mappedTable.createTable();
 dynamoDbClient.waiter().waitUntilTableExists(b -> b.tableName(tableName));
 
 
```
    Specified by:
    
    createTable in interface DynamoDbTable<T>
  - deleteItem
```
public T deleteItem(DeleteItemEnhancedRequest request)
```
    Description copied from interface: DynamoDbTable
    Deletes a single item from the mapped table using a supplied primary Key.
    The additional configuration parameters that the enhanced client supports are defined in the DeleteItemEnhancedRequest.
    This operation calls the low-level DynamoDB API DeleteItem operation. Consult the DeleteItem documentation for further details and constraints.
    Example:
```
 

 MyItem previouslyPersistedItem = mappedTable.delete(DeleteItemEnhancedRequest.builder().key(key).build());
 
 
```
    Specified by:
    
    deleteItem in interface DynamoDbTable<T>
    
    Parameters:
    
    request - A DeleteItemEnhancedRequest with key and optional directives for deleting an item from the table.
    
    Returns:
    
    The item that was persisted in the database before it was deleted.
  - deleteItem
```
public T deleteItem(Consumer<DeleteItemEnhancedRequest.Builder> requestConsumer)
```
    Description copied from interface: DynamoDbTable
    Deletes a single item from the mapped table using a supplied primary Key.
    The additional configuration parameters that the enhanced client supports are defined in the DeleteItemEnhancedRequest.
    This operation calls the low-level DynamoDB API DeleteItem operation. Consult the DeleteItem 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 DeleteItemEnhancedRequest.builder().
    Example:
```
 

 MyItem previouslyPersistedItem = mappedTable.delete(r -> r.key(key));
 
 
```
    Specified by:
    
    deleteItem in interface DynamoDbTable<T>
    
    Parameters:
    
    requestConsumer - A Consumer of DeleteItemEnhancedRequest with key and optional directives for deleting an item from the table.
    
    Returns:
    
    The item that was persisted in the database before it was deleted.
  - deleteItem
```
public T deleteItem(Key key)
```
    Description copied from interface: DynamoDbTable
    Deletes a single item from the mapped table using a supplied primary Key.
    This operation calls the low-level DynamoDB API DeleteItem operation. Consult the DeleteItem documentation for further details and constraints.
    Example:
```
 

 MyItem previouslyPersistedItem = mappedTable.delete(key);
 
 
```
    Specified by:
    
    deleteItem in interface DynamoDbTable<T>
    
    Parameters:
    
    key - A Key that will be used to match a specific record to delete from the database table.
    
    Returns:
    
    The item that was persisted in the database before it was deleted.
  - deleteItem
```
public T deleteItem(T keyItem)
```
    Description copied from interface: DynamoDbTable
    Deletes a single item from the mapped table using just the key of a supplied modelled 'key item' object.
    This operation calls the low-level DynamoDB API DeleteItem operation. Consult the DeleteItem documentation for further details and constraints.
    Example:
```
 

 MyItem previouslyPersistedItem = mappedTable.deleteItem(keyItem);
 
 
```
    Specified by:
    
    deleteItem in interface DynamoDbTable<T>
    
    Parameters:
    
    keyItem - A modelled item with the primary key fields set that will be used to match a specific record to delete from the database table.
    
    Returns:
    
    The item that was persisted in the database before it was deleted.
  - deleteItemWithResponse
```
public DeleteItemEnhancedResponse<T> deleteItemWithResponse(DeleteItemEnhancedRequest request)
```
    Description copied from interface: DynamoDbTable
    Deletes a single item from the mapped table using a supplied primary Key.
    The additional configuration parameters that the enhanced client supports are defined in the DeleteItemEnhancedRequest.
    This operation calls the low-level DynamoDB API DeleteItem operation. Consult the DeleteItem documentation for further details and constraints. Unlike DynamoDbTable.deleteItem(DeleteItemEnhancedRequest), this returns a response object, allowing the user to retrieve additional information from DynamoDB related to the API call, such as ConsumedCapacity if specified on the request.
    Example:
```
 

 DeleteItemEnhancedRequest request = DeleteItemEnhancedRequest.builder().key(key).build();
 DeleteItemEnhancedResponse<MyItem> response = mappedTable.deleteItemWithResponse(request);
 
 
```
    Specified by:
    
    deleteItemWithResponse in interface DynamoDbTable<T>
    
    Parameters:
    
    request - A DeleteItemEnhancedRequest with key and optional directives for deleting an item from the table.
    
    Returns:
    
    The response returned by DynamoDB.
  - deleteItemWithResponse
```
public DeleteItemEnhancedResponse<T> deleteItemWithResponse(Consumer<DeleteItemEnhancedRequest.Builder> requestConsumer)
```
    Description copied from interface: DynamoDbTable
    Deletes a single item from the mapped table using a supplied primary Key.
    The additional configuration parameters that the enhanced client supports are defined in the DeleteItemEnhancedRequest.
    This operation calls the low-level DynamoDB API DeleteItem operation. Consult the DeleteItem documentation for further details and constraints. Unlike DynamoDbTable.deleteItem(Consumer), this returns a response object, allowing the user to retrieve additional information from DynamoDB related to the API call, such as ConsumedCapacity if specified on the request.
    Note: This is a convenience method that creates an instance of the request builder avoiding the need to create one manually via DeleteItemEnhancedRequest.builder().
    Example:
```
 

 DeleteItemEnhancedResponse<MyItem> response = mappedTable.deleteWithResponse(r -> r.key(key));
 
 
```
    Specified by:
    
    deleteItemWithResponse in interface DynamoDbTable<T>
    
    Parameters:
    
    requestConsumer - A Consumer of DeleteItemEnhancedRequest with key and optional directives for deleting an item from the table.
    
    Returns:
    
    The response returned by DynamoDB.
  - getItem
```
public T getItem(GetItemEnhancedRequest request)
```
    Description copied from interface: DynamoDbTable
    Retrieves a single item from the mapped table using a supplied primary Key.
    The additional configuration parameters that the enhanced client supports are defined in the GetItemEnhancedRequest.
    This operation calls the low-level DynamoDB API GetItem operation. Consult the GetItem documentation for further details and constraints.
    Example:
```
 

 MyItem item = mappedTable.getItem(GetItemEnhancedRequest.builder().key(key).build());
 
 
```
    Specified by:
    
    getItem in interface DynamoDbTable<T>
    
    Parameters:
    
    request - A GetItemEnhancedRequest with key and optional directives for retrieving an item from the table.
    
    Returns:
    
    The retrieved item
  - getItem
```
public T getItem(Consumer<GetItemEnhancedRequest.Builder> requestConsumer)
```
    Description copied from interface: DynamoDbTable
    Retrieves a single item from the mapped table using a supplied primary Key.
    The additional configuration parameters that the enhanced client supports are defined in the GetItemEnhancedRequest.
    This operation calls the low-level DynamoDB API GetItem operation. Consult the GetItem 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 GetItemEnhancedRequest.builder().
    Example:
```
 

 MyItem item = mappedTable.getItem(r -> r.key(key));
 
 
```
    Specified by:
    
    getItem in interface DynamoDbTable<T>
    
    Parameters:
    
    requestConsumer - A Consumer of GetItemEnhancedRequest.Builder with key and optional directives for retrieving an item from the table.
    
    Returns:
    
    The retrieved item
  - getItem
```
public T getItem(Key key)
```
    Description copied from interface: DynamoDbTable
    Retrieves a single item from the mapped table using a supplied primary Key.
    This operation calls the low-level DynamoDB API GetItem operation. Consult the GetItem documentation for further details and constraints.
    Example:
```
 

 MyItem item = mappedTable.getItem(key);
 
 
```
    Specified by:
    
    getItem in interface DynamoDbTable<T>
    
    Parameters:
    
    key - A Key that will be used to match a specific record to retrieve from the database table.
    
    Returns:
    
    The retrieved item
  - getItem
```
public T getItem(T keyItem)
```
    Description copied from interface: DynamoDbTable
    Retrieves a single item from the mapped table using just the key of a supplied modelled 'key item'.
    This operation calls the low-level DynamoDB API GetItem operation. Consult the GetItem documentation for further details and constraints.
    Example:
```
 

 MyItem item = mappedTable.getItem(keyItem);
 
 
```
    Specified by:
    
    getItem in interface DynamoDbTable<T>
    
    Parameters:
    
    keyItem - A modelled item with the primary key fields set that will be used to match a specific record to retrieve from the database table.
    
    Returns:
    
    The retrieved item
  - query
```
public PageIterable<T> query(QueryEnhancedRequest request)
```
    Description copied from interface: DynamoDbTable
    Executes a query against the primary index of the table using a QueryConditional expression to retrieve a list of items matching the given conditions.
    The result can be accessed either through iterable Pages or Page.items() directly. If you are iterating the pages, the result is accessed through iterable pages (see Page) in an interactive way; each time a result page is retrieved, a query call is made to DynamoDb to get those entries. If no matches are found, the resulting iterator will contain an empty page. Results are sorted by sort key value in ascending order by default; this behavior can be overridden in the QueryEnhancedRequest.
    The additional configuration parameters that the enhanced client supports are defined in the QueryEnhancedRequest.
    This operation calls the low-level DynamoDB API Query operation. Consult the Query documentation for further details and constraints.
    Example:
    1) Iterating through pages
```
 
 QueryConditional queryConditional = QueryConditional.keyEqualTo(Key.builder().partitionValue("id-value").build());
 PageIterable<MyItem> results = table.query(QueryEnhancedRequest.builder()
                                                                        .queryConditional(queryConditional)
                                                                        .build());
 results.stream().forEach(p -> p.items().forEach(item -> System.out.println(item)))
 
 
```
    2) Iterating through items
```
 
 results.items().stream().forEach(item -> System.out.println(item));
 
 
```
    Specified by:
    
    query in interface DynamoDbTable<T>
    
    Parameters:
    
    request - A QueryEnhancedRequest defining the query conditions and how to handle the results.
    
    Returns:
    
    an iterator of type SdkIterable with paginated results (see Page).
    
    See Also:
    
    DynamoDbTable.query(QueryConditional), DynamoDbTable.query(Consumer), DynamoDbClient.queryPaginator(software.amazon.awssdk.services.dynamodb.model.QueryRequest)
  - query
```
public PageIterable<T> query(Consumer<QueryEnhancedRequest.Builder> requestConsumer)
```
    Description copied from interface: DynamoDbTable
    This is a convenience method that creates an instance of the request builder avoiding the need to create one manually via QueryEnhancedRequest.builder().
    Example:
```
 

 PageIterable<MyItem> results =
     mappedTable.query(r -> r.queryConditional(QueryConditional.keyEqualTo(k -> k.partitionValue("id-value"))));
 
 
```
    Specified by:
    
    query in interface DynamoDbTable<T>
    
    Parameters:
    
    requestConsumer - A Consumer of QueryEnhancedRequest defining the query conditions and how to handle the results.
    
    Returns:
    
    an iterator of type SdkIterable with paginated results (see Page).
    
    See Also:
    
    DynamoDbTable.query(QueryEnhancedRequest), DynamoDbTable.query(QueryConditional)
  - query
```
public PageIterable<T> query(QueryConditional queryConditional)
```
    Description copied from interface: DynamoDbTable
    Executes a query against the primary index of the table using a QueryConditional expression to retrieve a list of items matching the given conditions.
    Example:
```
 

 PageIterable<MyItem> results =
     mappedTable.query(QueryConditional.keyEqualTo(Key.builder().partitionValue("id-value").build()));
 
 
```
    Specified by:
    
    query in interface DynamoDbTable<T>
    
    Parameters:
    
    queryConditional - A QueryConditional defining the matching criteria for records to be queried.
    
    Returns:
    
    an iterator of type SdkIterable with paginated results (see Page).
    
    See Also:
    
    DynamoDbTable.query(QueryEnhancedRequest), DynamoDbTable.query(Consumer), DynamoDbClient.queryPaginator(software.amazon.awssdk.services.dynamodb.model.QueryRequest)
  - putItem
```
public void putItem(PutItemEnhancedRequest<T> request)
```
    Description copied from interface: DynamoDbTable
    Puts a single item in the mapped table. If the table contains an item with the same primary key, it will be replaced with this item.
    The additional configuration parameters that the enhanced client supports are defined in the PutItemEnhancedRequest.
    This operation calls the low-level DynamoDB API PutItem operation. Consult the PutItem documentation for further details and constraints.
    Example:
```
 

 mappedTable.putItem(PutItemEnhancedRequest.builder(MyItem.class).item(item).build());
 
 
```
    Specified by:
    
    putItem in interface DynamoDbTable<T>
    
    Parameters:
    
    request - A PutItemEnhancedRequest that includes the item to enter into the table, its class and optional directives.
  - putItem
```
public void putItem(Consumer<PutItemEnhancedRequest.Builder<T>> requestConsumer)
```
    Description copied from interface: DynamoDbTable
    Puts a single item in the mapped table. If the table contains an item with the same primary key, it will be replaced with this item.
    The additional configuration parameters that the enhanced client supports are defined in the PutItemEnhancedRequest.
    This operation calls the low-level DynamoDB API PutItem operation. Consult the PutItem documentation for further details and constraints.
    Example:
```
 

 mappedTable.putItem(r -> r.item(item));
 
 
```
    Specified by:
    
    putItem in interface DynamoDbTable<T>
    
    Parameters:
    
    requestConsumer - A Consumer of PutItemEnhancedRequest.Builder that includes the item to enter into the table, its class and optional directives.
  - putItem
```
public void putItem(T item)
```
    Description copied from interface: DynamoDbTable
    Puts a single item in the mapped table. If the table contains an item with the same primary key, it will be replaced with this item.
    This operation calls the low-level DynamoDB API PutItem operation. Consult the PutItem documentation for further details and constraints.
    Example:
```
 

 mappedTable.putItem(item);
 
 
```
    Specified by:
    
    putItem in interface DynamoDbTable<T>
    
    Parameters:
    
    item - the modelled item to be inserted into or overwritten in the database table.
  - putItemWithResponse
```
public PutItemEnhancedResponse<T> putItemWithResponse(PutItemEnhancedRequest<T> request)
```
    Description copied from interface: DynamoDbTable
    Puts a single item in the mapped table. If the table contains an item with the same primary key, it will be replaced with this item. This is similar to DynamoDbTable.putItem(PutItemEnhancedRequest) but returns PutItemEnhancedResponse for additional information.
    The additional configuration parameters that the enhanced client supports are defined in the PutItemEnhancedRequest.
    This operation calls the low-level DynamoDB API PutItem operation. Consult the PutItem documentation for further details and constraints.
    Example:
```
 

 mappedTable.putItem(PutItemEnhancedRequest.builder(MyItem.class).item(item).build());
 
 
```
    Specified by:
    
    putItemWithResponse in interface DynamoDbTable<T>
    
    Parameters:
    
    request - A PutItemEnhancedRequest that includes the item to enter into the table, its class and optional directives.
    
    Returns:
    
    The response returned by DynamoDB.
  - putItemWithResponse
```
public PutItemEnhancedResponse<T> putItemWithResponse(Consumer<PutItemEnhancedRequest.Builder<T>> requestConsumer)
```
    Description copied from interface: DynamoDbTable
    Puts a single item in the mapped table. If the table contains an item with the same primary key, it will be replaced with this item. This is similar to DynamoDbTable.putItem(PutItemEnhancedRequest) but returns PutItemEnhancedResponse for additional information.
    The additional configuration parameters that the enhanced client supports are defined in the PutItemEnhancedRequest.
    This operation calls the low-level DynamoDB API PutItem operation. Consult the PutItem documentation for further details and constraints.
    Example:
```
 

 mappedTable.putItem(PutItemEnhancedRequest.builder(MyItem.class).item(item).build());
 
 
```
    Specified by:
    
    putItemWithResponse in interface DynamoDbTable<T>
    
    Parameters:
    
    requestConsumer - A Consumer of PutItemEnhancedRequest.Builder that includes the item to enter into the table, its class and optional directives.
    
    Returns:
    
    The response returned by DynamoDB.
  - scan
```
public PageIterable<T> scan(ScanEnhancedRequest request)
```
    Description copied from interface: DynamoDbTable
    Scans the table and retrieves all items.
    The result can be accessed either through iterable Pages or items across all pages directly. Each time a result page is retrieved, a query call is made to DynamoDb to get those entries. If no matches are found, the resulting iterator will contain an empty page.
    The additional configuration parameters that the enhanced client supports are defined in the ScanEnhancedRequest.
    Example:
    1) Iterating through pages
```
 

 PageIterable<MyItem> results = mappedTable.scan(ScanEnhancedRequest.builder().consistentRead(true).build());
 results.stream().forEach(p -> p.items().forEach(item -> System.out.println(item)))
 
 
```
    2) Iterating through items
```
 

 PageIterable<MyItem> results = mappedTable.scan(ScanEnhancedRequest.builder().consistentRead(true).build());
 results.items().stream().forEach(item -> System.out.println(item));
 
 
```
    Specified by:
    
    scan in interface DynamoDbTable<T>
    
    Parameters:
    
    request - A ScanEnhancedRequest defining how to handle the results.
    
    Returns:
    
    an iterator of type SdkIterable with paginated results (see Page).
    
    See Also:
    
    DynamoDbTable.scan(Consumer), DynamoDbTable.scan(), DynamoDbClient.scanPaginator(software.amazon.awssdk.services.dynamodb.model.ScanRequest)
  - scan
```
public PageIterable<T> scan(Consumer<ScanEnhancedRequest.Builder> requestConsumer)
```
    Description copied from interface: DynamoDbTable
    This is a convenience method that creates an instance of the request builder avoiding the need to create one manually via ScanEnhancedRequest.builder().
    Example:
```
 

 PageIterable<MyItem> results = mappedTable.scan(r -> r.limit(5));
 
 
```
    Specified by:
    
    scan in interface DynamoDbTable<T>
    
    Parameters:
    
    requestConsumer - A Consumer of ScanEnhancedRequest defining the query conditions and how to handle the results.
    
    Returns:
    
    an iterator of type SdkIterable with paginated results (see Page).
    
    See Also:
    
    DynamoDbTable.scan(ScanEnhancedRequest), DynamoDbTable.scan()
  - scan
```
public PageIterable<T> scan()
```
    Description copied from interface: DynamoDbTable
    Scans the table and retrieves all items using default settings.
    The result can be accessed either through iterable Pages or items across all pages directly. Each time a result page is retrieved, a query call is made to DynamoDb to get those entries. If no matches are found, the resulting iterator will contain an empty page.
    Example:
```
 

 PageIterable<MyItem> results = mappedTable.scan();
 
 
```
    Specified by:
    
    scan in interface DynamoDbTable<T>
    
    Returns:
    
    an iterator of type SdkIterable with paginated results (see Page).
    
    See Also:
    
    DynamoDbTable.scan(ScanEnhancedRequest), DynamoDbTable.scan(Consumer), DynamoDbClient.scanPaginator(software.amazon.awssdk.services.dynamodb.model.ScanRequest)
  - updateItem
```
public T updateItem(UpdateItemEnhancedRequest<T> request)
```
    Description copied from interface: DynamoDbTable
    Updates an item in the mapped table, or adds it if it doesn't exist.
    The additional configuration parameters that the enhanced client supports are defined in the UpdateItemEnhancedRequest.
    This operation calls the low-level DynamoDB API UpdateItem operation. Consult the UpdateItem documentation for further details and constraints.
    Example:
```
 

 MyItem item = mappedTable.updateItem(UpdateItemEnhancedRequest.builder(MyItem.class).item(item).build());
 
 
```
    Specified by:
    
    updateItem in interface DynamoDbTable<T>
    
    Parameters:
    
    request - A UpdateItemEnhancedRequest that includes the item to be updated, its class and optional directives.
    
    Returns:
    
    The updated item
  - updateItem
```
public T updateItem(Consumer<UpdateItemEnhancedRequest.Builder<T>> requestConsumer)
```
    Description copied from interface: DynamoDbTable
    Updates an item in the mapped table, or adds it if it doesn't exist.
    The additional configuration parameters that the enhanced client supports are defined in the UpdateItemEnhancedRequest.
    This operation calls the low-level DynamoDB API UpdateItem operation. Consult the UpdateItem documentation for further details and constraints.
    Example:
```
 

 MyItem item = mappedTable.updateItem(r -> r.item(item));
 
 
```
    Specified by:
    
    updateItem in interface DynamoDbTable<T>
    
    Parameters:
    
    requestConsumer - A Consumer of UpdateItemEnhancedRequest.Builder that includes the item to be updated, its class and optional directives.
    
    Returns:
    
    The updated item
  - updateItem
```
public T updateItem(T item)
```
    Description copied from interface: DynamoDbTable
    Updates an item in the mapped table, or adds it if it doesn't exist.
    This operation calls the low-level DynamoDB API UpdateItem operation. Consult the UpdateItem documentation for further details and constraints.
    Example:
```
 

 MyItem item = mappedTable.updateItem(item);
 
 
```
    Specified by:
    
    updateItem in interface DynamoDbTable<T>
    
    Parameters:
    
    item - the modelled item to be inserted into or updated in the database table.
    
    Returns:
    
    The updated item
  - updateItemWithResponse
```
public UpdateItemEnhancedResponse<T> updateItemWithResponse(UpdateItemEnhancedRequest<T> request)
```
    Description copied from interface: DynamoDbTable
    Updates an item in the mapped table, or adds it if it doesn't exist. This is similar to DynamoDbTable.updateItem(UpdateItemEnhancedRequest)} but returns UpdateItemEnhancedResponse for additional information.
    This operation calls the low-level DynamoDB API UpdateItem operation. Consult the UpdateItem documentation for further details and constraints.
    Example:
```
 
 UpdateItemEnhancedRequest<MyItem> request = UpdateItemEnhancedRequest.builder(MyItem.class).item(myItem).build();
 UpdateItemEnhancedResponse<MyItem> response = mappedTable.updateItemWithResponse(request);
 
 
```
    Specified by:
    
    updateItemWithResponse in interface DynamoDbTable<T>
    
    Parameters:
    
    request - the modelled item to be inserted into or updated in the database table.
    
    Returns:
    
    The response returned by DynamoDB.
  - updateItemWithResponse
```
public UpdateItemEnhancedResponse<T> updateItemWithResponse(Consumer<UpdateItemEnhancedRequest.Builder<T>> requestConsumer)
```
    Description copied from interface: DynamoDbTable
    Updates an item in the mapped table, or adds it if it doesn't exist. This is similar to DynamoDbTable.updateItem(Consumer) but returns UpdateItemEnhancedResponse for additional information.
    This operation calls the low-level DynamoDB API UpdateItem operation. Consult the UpdateItem documentation for further details and constraints.
    Example:
```
 

 UpdateItemEnhancedResponse<MyItem> response = mappedTable.updateItemWithResponse(r ->r.item(myItem));
 
 
```
    Specified by:
    
    updateItemWithResponse in interface DynamoDbTable<T>
    
    Parameters:
    
    requestConsumer - A Consumer of UpdateItemEnhancedRequest.Builder that includes the item * to be updated, its class and optional directives.
    
    Returns:
    
    The response from DynamoDB.
  - keyFrom
```
public Key keyFrom(T item)
```
    Description copied from interface: MappedTableResource
    
    Creates a Key object from a modelled item. This key can be used in query conditionals and get operations to locate a specific record.
    
    Specified by:
    
    keyFrom in interface MappedTableResource<T>
    
    Parameters:
    
    item - The item to extract the key fields from.
    
    Returns:
    
    A key that has been initialized with the index values extracted from the modelled object.
  - deleteTable
```
public void deleteTable()
```
    Description copied from interface: DynamoDbTable
    Deletes a table in DynamoDb with the name and schema already defined for this DynamoDbTable.
    Use DynamoDbEnhancedClient.table(String, TableSchema) to define the mapped table resource.
    This operation calls the low-level DynamoDB API DeleteTable operation. Note that this is an asynchronous operation and that the table may not immediately be deleted. You can use DynamoDbWaiter.waitUntilTableNotExists(software.amazon.awssdk.services.dynamodb.model.DescribeTableRequest) in the underlying client.
    Example:
```
 

 mappedTable.deleteTable();
 
 
```
    Specified by:
    
    deleteTable in interface DynamoDbTable<T>
  - describeTable
```
public DescribeTableEnhancedResponse describeTable()
```
    Description copied from interface: DynamoDbTable
    Describes a table in DynamoDb with the name defined for this DynamoDbTable). This operation calls the low-level DynamoDB API DescribeTable operation, see {@link DynamoDbClient#describeTable(DescribeTableRequest)}
    Example:
```
 {@code

 DescribeTableEnhancedResponse response = mappedTable.describeTable();
 }
 
```
    Specified by:
    
    describeTable in interface DynamoDbTable<T>
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object

Class DefaultDynamoDbTable<T>

Method Summary

Methods inherited from class java.lang.Object

Method Detail

mapperExtension

tableSchema

dynamoDbClient

tableName

index

createTable

createTable

createTable

deleteItem

deleteItem

deleteItem

deleteItem

deleteItemWithResponse

deleteItemWithResponse

getItem

getItem

getItem

getItem

query

query

query

putItem

putItem

putItem

putItemWithResponse

putItemWithResponse

scan

scan

scan

updateItem

updateItem

updateItem

updateItemWithResponse

updateItemWithResponse

keyFrom

deleteTable

describeTable

equals

hashCode