tessl/maven-software-amazon-awssdk--dynamodb

AWS SDK for Java v2 DynamoDB client library for interacting with Amazon DynamoDB NoSQL database service

Overview

Eval results

Files

Data Operations

Name: tessl/maven-software-amazon-awssdk--dynamodb
Author: tessl

Core CRUD operations and advanced data manipulation capabilities for working with DynamoDB items. This includes basic item operations, querying and scanning, batch operations, and streaming capabilities.

Capabilities

Put Item

Creates a new item or replaces an existing item in a table.

/**
 * Creates a new item, or replaces an old item with a new item
 * @param request - The request containing table name, item data, and options
 * @return Response containing consumed capacity and item attributes
 */
PutItemResponse putItem(PutItemRequest request);

class PutItemRequest {
    static Builder builder();
    
    /** The name of the table to contain the item */
    String tableName();
    Builder tableName(String tableName);
    
    /** A map of attribute name/value pairs, one for each attribute */
    Map<String, AttributeValue> item();
    Builder item(Map<String, AttributeValue> item);
    
    /** Map of attribute names to expected attribute values */
    Map<String, ExpectedAttributeValue> expected();
    Builder expected(Map<String, ExpectedAttributeValue> expected);
    
    /** Determines the level of detail about consumed capacity returned */
    ReturnConsumedCapacity returnConsumedCapacity();
    Builder returnConsumedCapacity(ReturnConsumedCapacity returnConsumedCapacity);
    
    /** Determines whether item collection metrics are returned */
    ReturnItemCollectionMetrics returnItemCollectionMetrics();
    Builder returnItemCollectionMetrics(ReturnItemCollectionMetrics returnItemCollectionMetrics);
    
    /** Use ReturnValues if you want to get the item attributes as they appeared before they were updated */
    ReturnValue returnValues();
    Builder returnValues(ReturnValue returnValues);
    
    /** Condition expression that must evaluate to true for the operation to succeed */
    String conditionExpression();
    Builder conditionExpression(String conditionExpression);
    
    /** One or more substitution tokens for attribute names in an expression */
    Map<String, String> expressionAttributeNames();
    Builder expressionAttributeNames(Map<String, String> expressionAttributeNames);
    
    /** One or more values that can be substituted in an expression */
    Map<String, AttributeValue> expressionAttributeValues();
    Builder expressionAttributeValues(Map<String, AttributeValue> expressionAttributeValues);
}

class PutItemResponse {
    /** The item attributes as they appeared before they were updated */
    Map<String, AttributeValue> attributes();
    
    /** The capacity units consumed by the operation */
    ConsumedCapacity consumedCapacity();
    
    /** Information about item collection metrics */
    ItemCollectionMetrics itemCollectionMetrics();
}

Usage Example:

import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.*;
import java.util.Map;

DynamoDbClient client = DynamoDbClient.builder().build();

// Put a new item
Map<String, AttributeValue> item = Map.of(
    "userId", AttributeValue.builder().s("user123").build(),
    "name", AttributeValue.builder().s("John Doe").build(),
    "email", AttributeValue.builder().s("john@example.com").build(),
    "age", AttributeValue.builder().n("30").build()
);

PutItemResponse response = client.putItem(PutItemRequest.builder()
    .tableName("Users")
    .item(item)
    .conditionExpression("attribute_not_exists(userId)")  // Only if user doesn't exist
    .returnConsumedCapacity(ReturnConsumedCapacity.TOTAL)
    .build());

System.out.println("Consumed capacity: " + response.consumedCapacity().capacityUnits());

Get Item

Retrieves a single item from a table by primary key.

/**
 * Returns a set of attributes for the item with the given primary key
 * @param request - The request containing table name, key, and projection options
 * @return Response containing the item attributes
 */
GetItemResponse getItem(GetItemRequest request);

class GetItemRequest {
    static Builder builder();
    
    /** The name of the table containing the requested item */
    String tableName();
    Builder tableName(String tableName);
    
    /** A map of attribute names to AttributeValue objects, representing the primary key */
    Map<String, AttributeValue> key();
    Builder key(Map<String, AttributeValue> key);
    
    /** List of attributes to retrieve */
    List<String> attributesToGet();
    Builder attributesToGet(Collection<String> attributesToGet);
    
    /** Determines the read consistency model */
    Boolean consistentRead();
    Builder consistentRead(Boolean consistentRead);
    
    /** Determines the level of detail about consumed capacity returned */
    ReturnConsumedCapacity returnConsumedCapacity();
    Builder returnConsumedCapacity(ReturnConsumedCapacity returnConsumedCapacity);
    
    /** A string that identifies one or more attributes to retrieve from the table */
    String projectionExpression();
    Builder projectionExpression(String projectionExpression);
    
    /** One or more substitution tokens for attribute names in an expression */
    Map<String, String> expressionAttributeNames();
    Builder expressionAttributeNames(Map<String, String> expressionAttributeNames);
}

class GetItemResponse {
    /** A map of attribute names to AttributeValue objects */
    Map<String, AttributeValue> item();
    
    /** The capacity units consumed by the operation */
    ConsumedCapacity consumedCapacity();
}

Usage Example:

// Get a specific item
GetItemResponse response = client.getItem(GetItemRequest.builder()
    .tableName("Users")
    .key(Map.of("userId", AttributeValue.builder().s("user123").build()))
    .projectionExpression("userId, #n, email")  // Only get specific attributes
    .expressionAttributeNames(Map.of("#n", "name"))  // 'name' is a reserved word
    .consistentRead(true)  // Strong consistency
    .build());

if (response.hasItem()) {
    Map<String, AttributeValue> item = response.item();
    String name = item.get("name").s();
    String email = item.get("email").s();
    System.out.println("User: " + name + " (" + email + ")");
} else {
    System.out.println("User not found");
}

Update Item

Edits an existing item's attributes or adds a new item if it doesn't exist.

/**
 * Edits an existing item's attributes, or adds a new item to the table if it does not already exist
 * @param request - The request containing table name, key, and update expression
 * @return Response containing updated attributes and consumed capacity
 */
UpdateItemResponse updateItem(UpdateItemRequest request);

class UpdateItemRequest {
    static Builder builder();
    
    /** The name of the table containing the item to update */
    String tableName();
    Builder tableName(String tableName);
    
    /** The primary key of the item to be updated */
    Map<String, AttributeValue> key();
    Builder key(Map<String, AttributeValue> key);
    
    /** Map of attribute updates */
    Map<String, AttributeValueUpdate> attributeUpdates();
    Builder attributeUpdates(Map<String, AttributeValueUpdate> attributeUpdates);
    
    /** Map of attribute names to expected attribute values */
    Map<String, ExpectedAttributeValue> expected();
    Builder expected(Map<String, ExpectedAttributeValue> expected);
    
    /** Use ReturnValues if you want to get the item attributes as they appear before or after they are updated */
    ReturnValue returnValues();
    Builder returnValues(ReturnValue returnValues);
    
    /** Determines the level of detail about consumed capacity returned */
    ReturnConsumedCapacity returnConsumedCapacity();
    Builder returnConsumedCapacity(ReturnConsumedCapacity returnConsumedCapacity);
    
    /** Determines whether item collection metrics are returned */
    ReturnItemCollectionMetrics returnItemCollectionMetrics();
    Builder returnItemCollectionMetrics(ReturnItemCollectionMetrics returnItemCollectionMetrics);
    
    /** An expression that defines one or more attributes to be updated */
    String updateExpression();
    Builder updateExpression(String updateExpression);
    
    /** A condition that must be satisfied for the update to succeed */
    String conditionExpression();
    Builder conditionExpression(String conditionExpression);
    
    /** One or more substitution tokens for attribute names in an expression */
    Map<String, String> expressionAttributeNames();
    Builder expressionAttributeNames(Map<String, String> expressionAttributeNames);
    
    /** One or more values that can be substituted in an expression */
    Map<String, AttributeValue> expressionAttributeValues();
    Builder expressionAttributeValues(Map<String, AttributeValue> expressionAttributeValues);
}

class UpdateItemResponse {
    /** A map of attribute names to AttributeValue objects representing the item as it appears before or after it was updated */
    Map<String, AttributeValue> attributes();
    
    /** The capacity units consumed by the operation */
    ConsumedCapacity consumedCapacity();
    
    /** Information about item collection metrics */
    ItemCollectionMetrics itemCollectionMetrics();
}

Usage Example:

// Update user attributes
UpdateItemResponse response = client.updateItem(UpdateItemRequest.builder()
    .tableName("Users")
    .key(Map.of("userId", AttributeValue.builder().s("user123").build()))
    .updateExpression("SET email = :e, age = age + :inc, lastLogin = :now")
    .conditionExpression("attribute_exists(userId)")  // Only if user exists
    .expressionAttributeValues(Map.of(
        ":e", AttributeValue.builder().s("newemail@example.com").build(),
        ":inc", AttributeValue.builder().n("1").build(),
        ":now", AttributeValue.builder().s("2025-09-07T17:00:00Z").build()
    ))
    .returnValues(ReturnValue.ALL_NEW)  // Return item after update
    .build());

Map<String, AttributeValue> updatedItem = response.attributes();

Delete Item

Deletes a single item from a table by primary key.

/**
 * Deletes a single item in a table by primary key
 * @param request - The request containing table name, key, and conditions
 * @return Response containing old attributes and consumed capacity
 */
DeleteItemResponse deleteItem(DeleteItemRequest request);

class DeleteItemRequest {
    static Builder builder();
    
    /** The name of the table from which to delete the item */
    String tableName();
    Builder tableName(String tableName);
    
    /** A map of attribute names to AttributeValue objects, representing the primary key */
    Map<String, AttributeValue> key();
    Builder key(Map<String, AttributeValue> key);
    
    /** Map of attribute names to expected attribute values */
    Map<String, ExpectedAttributeValue> expected();
    Builder expected(Map<String, ExpectedAttributeValue> expected);
    
    /** Use ReturnValues if you want to get the item attributes as they appeared before they were deleted */
    ReturnValue returnValues();
    Builder returnValues(ReturnValue returnValues);
    
    /** Determines the level of detail about consumed capacity returned */
    ReturnConsumedCapacity returnConsumedCapacity();
    Builder returnConsumedCapacity(ReturnConsumedCapacity returnConsumedCapacity);
    
    /** Determines whether item collection metrics are returned */
    ReturnItemCollectionMetrics returnItemCollectionMetrics();
    Builder returnItemCollectionMetrics(ReturnItemCollectionMetrics returnItemCollectionMetrics);
    
    /** A condition that must be satisfied for the delete to succeed */
    String conditionExpression();
    Builder conditionExpression(String conditionExpression);
    
    /** One or more substitution tokens for attribute names in an expression */
    Map<String, String> expressionAttributeNames();
    Builder expressionAttributeNames(Map<String, String> expressionAttributeNames);
    
    /** One or more values that can be substituted in an expression */
    Map<String, AttributeValue> expressionAttributeValues();
    Builder expressionAttributeValues(Map<String, AttributeValue> expressionAttributeValues);
}

class DeleteItemResponse {
    /** A map of attribute names to AttributeValue objects, representing the item as it appeared before it was deleted */
    Map<String, AttributeValue> attributes();
    
    /** The capacity units consumed by the operation */
    ConsumedCapacity consumedCapacity();
    
    /** Information about item collection metrics */
    ItemCollectionMetrics itemCollectionMetrics();
}

Query Operations

Finds items based on primary key values and optional sort key conditions.

/**
 * Finds items based on primary key values
 * @param request - The request containing table name, key conditions, and filters
 * @return Response containing matching items and pagination info
 */
QueryResponse query(QueryRequest request);

class QueryRequest {
    static Builder builder();
    
    /** The name of the table containing the requested items */
    String tableName();
    Builder tableName(String tableName);
    
    /** The name of an index to query */
    String indexName();
    Builder indexName(String indexName);
    
    /** The attributes to be returned in the result */
    Select select();
    Builder select(Select select);
    
    /** List of attributes to retrieve */
    List<String> attributesToGet();
    Builder attributesToGet(Collection<String> attributesToGet);
    
    /** The maximum number of items to evaluate */
    Integer limit();
    Builder limit(Integer limit);
    
    /** Determines the read consistency model */
    Boolean consistentRead();
    Builder consistentRead(Boolean consistentRead);
    
    /** The condition that specifies the key values for items to be retrieved */
    Map<String, Condition> keyConditions();
    Builder keyConditions(Map<String, Condition> keyConditions);
    
    /** A condition that must be satisfied to include an item in the result set */
    String filterExpression();
    Builder filterExpression(String filterExpression);
    
    /** A condition that defines the key values for items to be retrieved */
    String keyConditionExpression();
    Builder keyConditionExpression(String keyConditionExpression);
    
    /** A string that identifies one or more attributes to retrieve from the table */
    String projectionExpression();
    Builder projectionExpression(String projectionExpression);
    
    /** One or more substitution tokens for attribute names in expressions */
    Map<String, String> expressionAttributeNames();
    Builder expressionAttributeNames(Map<String, String> expressionAttributeNames);
    
    /** One or more values that can be substituted in expressions */
    Map<String, AttributeValue> expressionAttributeValues();
    Builder expressionAttributeValues(Map<String, AttributeValue> expressionAttributeValues);
    
    /** Specifies the order for index traversal */
    Boolean scanIndexForward();
    Builder scanIndexForward(Boolean scanIndexForward);
    
    /** The primary key of the first item that this operation will evaluate */
    Map<String, AttributeValue> exclusiveStartKey();
    Builder exclusiveStartKey(Map<String, AttributeValue> exclusiveStartKey);
    
    /** Determines the level of detail about consumed capacity returned */
    ReturnConsumedCapacity returnConsumedCapacity();
    Builder returnConsumedCapacity(ReturnConsumedCapacity returnConsumedCapacity);
}

class QueryResponse {
    /** An array of item attributes that match the query criteria */
    List<Map<String, AttributeValue>> items();
    
    /** The number of items in the response */
    Integer count();
    
    /** The number of items evaluated, before applying filters */
    Integer scannedCount();
    
    /** The primary key of the item where the operation stopped */
    Map<String, AttributeValue> lastEvaluatedKey();
    
    /** The capacity units consumed by the operation */
    ConsumedCapacity consumedCapacity();
}

Usage Example:

// Query items by partition key and sort key range
QueryResponse response = client.query(QueryRequest.builder()
    .tableName("Orders")
    .keyConditionExpression("customerId = :cid AND orderDate BETWEEN :start AND :end")
    .expressionAttributeValues(Map.of(
        ":cid", AttributeValue.builder().s("customer123").build(),
        ":start", AttributeValue.builder().s("2025-01-01").build(),
        ":end", AttributeValue.builder().s("2025-12-31").build()
    ))
    .projectionExpression("orderId, orderDate, totalAmount")
    .limit(20)  // Limit results
    .scanIndexForward(false)  // Descending order
    .build());

System.out.println("Found " + response.count() + " orders");
for (Map<String, AttributeValue> item : response.items()) {
    String orderId = item.get("orderId").s();
    String orderDate = item.get("orderDate").s();
    System.out.println("Order: " + orderId + " on " + orderDate);
}

// Handle pagination
if (response.hasLastEvaluatedKey()) {
    // Use lastEvaluatedKey as exclusiveStartKey in next query
    Map<String, AttributeValue> startKey = response.lastEvaluatedKey();
}

Scan Operations

Reads every item in a table or secondary index.

/**
 * Returns one or more items and item attributes by accessing every item in a table or a secondary index
 * @param request - The request containing table name, filters, and scan options
 * @return Response containing all matching items and pagination info
 */
ScanResponse scan(ScanRequest request);

class ScanRequest {
    static Builder builder();
    
    /** The name of the table containing the requested items */
    String tableName();
    Builder tableName(String tableName);
    
    /** The name of a secondary index to scan */
    String indexName();
    Builder indexName(String indexName);
    
    /** List of attributes to retrieve */
    List<String> attributesToGet();
    Builder attributesToGet(Collection<String> attributesToGet);
    
    /** The maximum number of items to evaluate */
    Integer limit();
    Builder limit(Integer limit);
    
    /** The attributes to be returned in the result */
    Select select();
    Builder select(Select select);
    
    /** A map of attribute names to values, used for filtering */
    Map<String, Condition> scanFilter();
    Builder scanFilter(Map<String, Condition> scanFilter);
    
    /** A string that contains conditions that DynamoDB applies after the Scan operation */
    String filterExpression();
    Builder filterExpression(String filterExpression);
    
    /** A string that identifies one or more attributes to retrieve from the table */
    String projectionExpression();
    Builder projectionExpression(String projectionExpression);
    
    /** One or more substitution tokens for attribute names in expressions */
    Map<String, String> expressionAttributeNames();
    Builder expressionAttributeNames(Map<String, String> expressionAttributeNames);
    
    /** One or more values that can be substituted in expressions */
    Map<String, AttributeValue> expressionAttributeValues();
    Builder expressionAttributeValues(Map<String, AttributeValue> expressionAttributeValues);
    
    /** The primary key of the first item that this operation will evaluate */
    Map<String, AttributeValue> exclusiveStartKey();
    Builder exclusiveStartKey(Map<String, AttributeValue> exclusiveStartKey);
    
    /** Determines the level of detail about consumed capacity returned */
    ReturnConsumedCapacity returnConsumedCapacity();
    Builder returnConsumedCapacity(ReturnConsumedCapacity returnConsumedCapacity);
    
    /** For a parallel Scan request, TotalSegments specifies the total number of segments */
    Integer totalSegments();
    Builder totalSegments(Integer totalSegments);
    
    /** For a parallel Scan request, Segment identifies an individual segment to be scanned */
    Integer segment();
    Builder segment(Integer segment);
    
    /** Determines the read consistency model */
    Boolean consistentRead();
    Builder consistentRead(Boolean consistentRead);
}

class ScanResponse {
    /** An array of item attributes that match the scan criteria */
    List<Map<String, AttributeValue>> items();
    
    /** The number of items in the response */
    Integer count();
    
    /** The number of items evaluated, before applying filters */
    Integer scannedCount();
    
    /** The primary key of the item where the operation stopped */
    Map<String, AttributeValue> lastEvaluatedKey();
    
    /** The capacity units consumed by the operation */
    ConsumedCapacity consumedCapacity();
}

Batch Operations

Perform multiple read or write operations in a single request for improved efficiency.

/**
 * Returns the attributes of one or more items from one or more tables
 * @param request - The request containing multiple table keys to retrieve
 * @return Response containing retrieved items and unprocessed keys
 */
BatchGetItemResponse batchGetItem(BatchGetItemRequest request);

class BatchGetItemRequest {
    static Builder builder();
    
    /** A map of one or more table names and key sets to retrieve */
    Map<String, KeysAndAttributes> requestItems();
    Builder requestItems(Map<String, KeysAndAttributes> requestItems);
    
    /** Determines the level of detail about consumed capacity returned */
    ReturnConsumedCapacity returnConsumedCapacity();
    Builder returnConsumedCapacity(ReturnConsumedCapacity returnConsumedCapacity);
}

class KeysAndAttributes {
    static Builder builder();
    
    /** The primary keys of the items to retrieve */
    List<Map<String, AttributeValue>> keys();
    Builder keys(Collection<Map<String, AttributeValue>> keys);
    
    /** List of attributes to retrieve */
    List<String> attributesToGet();
    Builder attributesToGet(Collection<String> attributesToGet);
    
    /** Determines the read consistency model */
    Boolean consistentRead();
    Builder consistentRead(Boolean consistentRead);
    
    /** A string that identifies one or more attributes to retrieve */
    String projectionExpression();
    Builder projectionExpression(String projectionExpression);
    
    /** One or more substitution tokens for attribute names */
    Map<String, String> expressionAttributeNames();
    Builder expressionAttributeNames(Map<String, String> expressionAttributeNames);
}

class BatchGetItemResponse {
    /** A map of table name to list of items */
    Map<String, List<Map<String, AttributeValue>>> responses();
    
    /** A map of tables and their respective keys that were not processed */
    Map<String, KeysAndAttributes> unprocessedKeys();
    
    /** The read capacity units consumed by the operation */
    List<ConsumedCapacity> consumedCapacity();
}

/**
 * Puts or deletes multiple items in one or more tables
 * @param request - The request containing multiple write operations
 * @return Response containing unprocessed items and consumed capacity
 */
BatchWriteItemResponse batchWriteItem(BatchWriteItemRequest request);

class BatchWriteItemRequest {
    static Builder builder();
    
    /** A map of one or more table names and write requests */
    Map<String, List<WriteRequest>> requestItems();
    Builder requestItems(Map<String, List<WriteRequest>> requestItems);
    
    /** Determines the level of detail about consumed capacity returned */
    ReturnConsumedCapacity returnConsumedCapacity();
    Builder returnConsumedCapacity(ReturnConsumedCapacity returnConsumedCapacity);
    
    /** Determines whether item collection metrics are returned */
    ReturnItemCollectionMetrics returnItemCollectionMetrics();
    Builder returnItemCollectionMetrics(ReturnItemCollectionMetrics returnItemCollectionMetrics);
}

class WriteRequest {
    static Builder builder();
    
    /** A request to perform a PutItem operation */
    PutRequest putRequest();
    Builder putRequest(PutRequest putRequest);
    
    /** A request to perform a DeleteItem operation */
    DeleteRequest deleteRequest();
    Builder deleteRequest(DeleteRequest deleteRequest);
}

class BatchWriteItemResponse {
    /** A map of tables and their respective unprocessed write requests */
    Map<String, List<WriteRequest>> unprocessedItems();
    
    /** The write capacity units consumed by the operation */
    Map<String, List<ItemCollectionMetrics>> itemCollectionMetrics();
    
    /** The capacity units consumed by the operation */
    List<ConsumedCapacity> consumedCapacity();
}

Usage Example:

// Batch get multiple items from different tables
Map<String, KeysAndAttributes> requestItems = Map.of(
    "Users", KeysAndAttributes.builder()
        .keys(List.of(
            Map.of("userId", AttributeValue.builder().s("user1").build()),
            Map.of("userId", AttributeValue.builder().s("user2").build())
        ))
        .projectionExpression("userId, name, email")
        .build(),
    "Orders", KeysAndAttributes.builder()
        .keys(List.of(
            Map.of("orderId", AttributeValue.builder().s("order1").build())
        ))
        .build()
);

BatchGetItemResponse response = client.batchGetItem(BatchGetItemRequest.builder()
    .requestItems(requestItems)
    .returnConsumedCapacity(ReturnConsumedCapacity.TOTAL)
    .build());

// Process responses
Map<String, List<Map<String, AttributeValue>>> responses = response.responses();
List<Map<String, AttributeValue>> users = responses.get("Users");
List<Map<String, AttributeValue>> orders = responses.get("Orders");

// Handle unprocessed keys (retry if needed)
if (response.hasUnprocessedKeys()) {
    Map<String, KeysAndAttributes> unprocessed = response.unprocessedKeys();
    // Retry with exponential backoff
}

Additional Type Definitions

Condition and Filter Types

class Condition {
    static Builder builder();
    
    /** A list of one or more values to evaluate against the supplied attribute */
    List<AttributeValue> attributeValueList();
    Builder attributeValueList(Collection<AttributeValue> attributeValueList);
    
    /** A comparator for evaluating attributes */
    ComparisonOperator comparisonOperator();
    Builder comparisonOperator(ComparisonOperator comparisonOperator);
}

class ExpectedAttributeValue {
    static Builder builder();
    
    /** Represents the data for the expected attribute */
    AttributeValue value();
    Builder value(AttributeValue value);
    
    /** Causes DynamoDB to evaluate the value before attempting a conditional operation */
    Boolean exists();
    Builder exists(Boolean exists);
    
    /** A comparator for evaluating attributes in the AttributeValueList */
    ComparisonOperator comparisonOperator();
    Builder comparisonOperator(ComparisonOperator comparisonOperator);
    
    /** One or more values to evaluate against the supplied attribute */
    List<AttributeValue> attributeValueList();
    Builder attributeValueList(Collection<AttributeValue> attributeValueList);
}

Batch Operation Types

class PutRequest {
    static Builder builder();
    
    /** A map of attribute name/value pairs, one for each attribute */
    Map<String, AttributeValue> item();
    Builder item(Map<String, AttributeValue> item);
}

class DeleteRequest {
    static Builder builder();
    
    /** A map of attribute names to AttributeValue objects, representing the primary key */
    Map<String, AttributeValue> key();
    Builder key(Map<String, AttributeValue> key);
}

Capacity and Metrics Types

class ConsumedCapacity {
    static Builder builder();
    
    /** The name of the table that was affected by the operation */
    String tableName();
    Builder tableName(String tableName);
    
    /** The total number of capacity units consumed by the operation */
    Double capacityUnits();
    Builder capacityUnits(Double capacityUnits);
    
    /** The total number of read capacity units consumed by the operation */
    Double readCapacityUnits();
    Builder readCapacityUnits(Double readCapacityUnits);
    
    /** The total number of write capacity units consumed by the operation */
    Double writeCapacityUnits(); 
    Builder writeCapacityUnits(Double writeCapacityUnits);
    
    /** The amount of throughput consumed on the table */
    Capacity table();
    Builder table(Capacity table);
    
    /** The amount of throughput consumed on each local secondary index */
    Map<String, Capacity> localSecondaryIndexes();
    Builder localSecondaryIndexes(Map<String, Capacity> localSecondaryIndexes);
    
    /** The amount of throughput consumed on each global secondary index */
    Map<String, Capacity> globalSecondaryIndexes();
    Builder globalSecondaryIndexes(Map<String, Capacity> globalSecondaryIndexes);
}

class Capacity {
    static Builder builder();
    
    /** The total number of read capacity units consumed on a table or an index */
    Double readCapacityUnits();
    Builder readCapacityUnits(Double readCapacityUnits);
    
    /** The total number of write capacity units consumed on a table or an index */
    Double writeCapacityUnits();
    Builder writeCapacityUnits(Double writeCapacityUnits);
    
    /** The total number of capacity units consumed on a table or an index */
    Double capacityUnits();
    Builder capacityUnits(Double capacityUnits);
}

class ItemCollectionMetrics {
    static Builder builder();
    
    /** The partition key value of the item collection */
    Map<String, AttributeValue> itemCollectionKey();
    Builder itemCollectionKey(Map<String, AttributeValue> itemCollectionKey);
    
    /** An estimate of item collection size, in gigabytes */
    List<Double> sizeEstimateRangeGB();
    Builder sizeEstimateRangeGB(Collection<Double> sizeEstimateRangeGB);
}

Enum Definitions

enum ReturnValue {
    NONE("NONE"),
    ALL_OLD("ALL_OLD"),
    UPDATED_OLD("UPDATED_OLD"),
    ALL_NEW("ALL_NEW"),
    UPDATED_NEW("UPDATED_NEW");
}

enum ReturnConsumedCapacity {
    INDEXES("INDEXES"),
    TOTAL("TOTAL"),
    NONE("NONE");
}

enum ReturnItemCollectionMetrics {
    SIZE("SIZE"),
    NONE("NONE");
}

enum Select {
    ALL_ATTRIBUTES("ALL_ATTRIBUTES"),
    ALL_PROJECTED_ATTRIBUTES("ALL_PROJECTED_ATTRIBUTES"),
    SPECIFIC_ATTRIBUTES("SPECIFIC_ATTRIBUTES"),
    COUNT("COUNT");
}

enum ConditionalOperator {
    AND("AND"),
    OR("OR");
}

Install with Tessl CLI

npx tessl i tessl/maven-software-amazon-awssdk--dynamodb

docs

tessl/maven-software-amazon-awssdk--dynamodb

data-operations.md.css-3qkkll{font-size:var(--chakra-font-sizes-sm);font-weight:var(--chakra-font-weights-normal);color:var(--chakra-colors-gray-300);}docs/

Data Operations

Capabilities

Put Item

Get Item

Update Item

Delete Item

Query Operations

Scan Operations

Batch Operations

Additional Type Definitions

Condition and Filter Types

Batch Operation Types

Capacity and Metrics Types

Enum Definitions

data-operations.mddocs/