Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2014-2015 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 com.amazonaws.services.dynamodbv2.document;
 
 import java.util.List;
 import java.util.Map;
 
 
A DynamoDB table. Instance of this class is typically obtained via DynamoDB.getTable(java.lang.String).
 
 public class Table implements PutItemApiGetItemApiQueryApiScanApi,
         UpdateItemApiDeleteItemApi {
     private static final long SLEEP_TIME_MILLIS = 5000;
     private final String tableName;
     private final AmazonDynamoDB client;
     private volatile TableDescription tableDescription;
 
     private final PutItemImpl putItemDelegate;
     private final GetItemImpl getItemDelegate;
     private final UpdateItemImpl updateItemDelegate;
     private final DeleteItemImpl deleteItemDelegate;
 
     private final QueryImpl queryDelegate;
     private final ScanImpl scanDelegate;
 
     public Table(AmazonDynamoDB clientString tableName) {
         this(clienttableNamenull);
     }
 
     public Table(AmazonDynamoDB clientString tableName,
             TableDescription tableDescription) {
         if (client == null)
             throw new IllegalArgumentException("client must be specified");
         if (tableName == null || tableName.trim().length() == 0)
             throw new IllegalArgumentException("table name must not be null or empty");
         this. = client;
         this. = tableName;
         this. = tableDescription;
 
         this. = new PutItemImpl(clientthis);
        this. = new GetItemImpl(clientthis);
        this. = new UpdateItemImpl(clientthis);
        this. = new DeleteItemImpl(clientthis);
        this. = new QueryImpl(clientthis);
        this.  = new ScanImpl(clientthis);
    }
    public String getTableName() {
        return ;
    }

    
Returns the table description; or null if the table description has not yet been described via describe(). No network call.
    public TableDescription getDescription() {
        return ;
    }

    
Retrieves the table description from DynamoDB. Involves network calls. Meant to be called as infrequently as possible to avoid throttling exception from the server side.

Returns:
a non-null table description
Throws:
com.amazonaws.services.dynamodbv2.model.ResourceNotFoundException if the table doesn't exist
    public TableDescription describe() {
        DescribeTableResult result = .describeTable(
                InternalUtils.applyUserAgent(new DescribeTableRequest()));
        return  = result.getTable();
    }

    
Gets a reference to the specified index. No network call.
    public Index getIndex(String indexName) {
        return new Index(indexNamethis);
    }
    @Override
    public PutItemOutcome putItem(Item item) {
        return .putItem(item);
    }
    @Override
    public PutItemOutcome putItem(Item itemExpected... expected) {
        return .putItem(itemexpected);
    }
    @Override
    public PutItemOutcome putItem(Item itemString conditionExpression,
            Map<StringStringnameMapMap<StringObjectvalueMap) {
        return .putItem(itemconditionExpressionnameMap,
                valueMap);
    }
    @Override
    public PutItemOutcome putItem(PutItemSpec spec) {
        return .putItem(spec);
    }
    @Override
    public GetItemOutcome getItemOutcome(KeyAttribute... primaryKeyComponents) {
        return .getItemOutcome(primaryKeyComponents);
    }
    @Override
    public GetItemOutcome getItemOutcome(PrimaryKey primaryKey) {
        return .getItemOutcome(primaryKey);
    }
    @Override
    public GetItemOutcome getItemOutcome(PrimaryKey primaryKey,
            String projectionExpressionMap<StringStringnameMap) {
        return .getItemOutcome(primaryKeyprojectionExpression,
                nameMap);
    }
    @Override
    public GetItemOutcome getItemOutcome(GetItemSpec params) {
        return .getItemOutcome(params);
    }
    @Override
    public UpdateItemOutcome updateItem(PrimaryKey primaryKey,
            AttributeUpdate... attributeUpdates) {
        return .updateItem(primaryKeyattributeUpdates);
    }
    @Override
    public UpdateItemOutcome updateItem(PrimaryKey primaryKey,
            Collection<ExpectedexpectedAttributeUpdate... attributeUpdates) {
        return .updateItem(primaryKeyexpected,
                attributeUpdates);
    }
    @Override
    public UpdateItemOutcome updateItem(PrimaryKey primaryKey,
            String updateExpressionMap<StringStringnameMap,
            Map<StringObjectvalueMap) {
        return .updateItem(primaryKeyupdateExpression,
                nameMapvalueMap);
    }
    @Override
    public UpdateItemOutcome updateItem(PrimaryKey primaryKey,
            String updateExpressionString conditionExpression,
            Map<StringStringnameMapMap<StringObjectvalueMap) {
        return .updateItem(primaryKeyupdateExpression,
                conditionExpressionnameMapvalueMap);
    }
    @Override
    public UpdateItemOutcome updateItem(UpdateItemSpec updateItemSpec) {
        return .updateItem(updateItemSpec);
    }
    @Override
    public ItemCollection<QueryOutcomequery(String hashKeyNameObject hashKeyValue) {
        return .query(hashKeyNamehashKeyValue);
    }
    @Override
    public ItemCollection<QueryOutcomequery(KeyAttribute hashKey) {
        return .query(hashKey);
    }
    @Override
    public ItemCollection<QueryOutcomequery(KeyAttribute hashKey,
            RangeKeyCondition rangeKeyCondition) {
        return .query(hashKeyrangeKeyCondition);
    }
    @Override
    public ItemCollection<QueryOutcomequery(KeyAttribute hashKey,
            RangeKeyCondition rangeKeyConditionString filterExpression,
            String projectionExpression,Map<StringStringnameMap,
            Map<StringObjectvalueMap) {
        return .query(hashKeyrangeKeyCondition,
                filterExpressionprojectionExpressionnameMapvalueMap);
    }
    @Override
    public ItemCollection<QueryOutcomequery(KeyAttribute hashKey,
            RangeKeyCondition rangeKeyConditionQueryFilter... queryFilters) {
        return .query(hashKeyrangeKeyConditionqueryFilters);
    }
    @Override
    public ItemCollection<QueryOutcomequery(KeyAttribute hashKey,
            RangeKeyCondition rangeKeyConditionString filterExpression,
            Map<StringStringnameMapMap<StringObjectvalueMap) {
        return .query(hashKeyrangeKeyCondition,
                filterExpressionnameMapvalueMap);
    }
    @Override
    public ItemCollection<QueryOutcomequery(QuerySpec spec) {
        return .query(spec);
    }
    @Override
    public ItemCollection<ScanOutcomescan(ScanFilter... scanFilters) {
        return .scan(scanFilters);
    }
    @Override
    public ItemCollection<ScanOutcomescan(String filterExpression,
            Map<StringStringnameMapMap<StringObjectvalueMap) {
        return .scan(filterExpressionnameMapvalueMap);
    }
    @Override
    public ItemCollection<ScanOutcomescan(String filterExpression,
            String projectionExpressionMap<StringStringnameMap,
            Map<StringObjectvalueMap) {
        return .scan(filterExpressionprojectionExpressionnameMapvalueMap);
    }
    @Override
    public ItemCollection<ScanOutcomescan(ScanSpec params) {
        return .scan(params);
    }
    @Beta
    public ItemCollection<ScanOutcomescan(ScanExpressionSpec scanExpressions) {
        return .scan(new ScanSpec()
            .withProjectionExpression(scanExpressions.getProjectionExpression())
            .withFilterExpression(scanExpressions.getFilterExpression())
            .withNameMap(scanExpressions.getNameMap())
            .withValueMap(scanExpressions.getValueMap()));
    }
    @Override
    public DeleteItemOutcome deleteItem(KeyAttribute... primaryKeyComponents) {
        return .deleteItem(primaryKeyComponents);
    }
    @Override
    public DeleteItemOutcome deleteItem(PrimaryKey primaryKey) {
        return .deleteItem(primaryKey);
    }
    @Override
    public DeleteItemOutcome deleteItem(PrimaryKey primaryKey,
            Expected... expected) {
        return .deleteItem(primaryKeyexpected);
    }
    @Override
    public DeleteItemOutcome deleteItem(PrimaryKey primaryKey,
            String conditionExpressionMap<StringStringnameMap,
            Map<StringObjectvalueMap) {
        return .deleteItem(primaryKey,
                conditionExpressionnameMapvalueMap);
    }
    @Beta
    public DeleteItemOutcome deleteItem(PrimaryKey primaryKey,
            DeleteItemExpressionSpec conditionExpressions) {
        return .deleteItem(primaryKey,
                conditionExpressions.getConditionExpression(),
                conditionExpressions.getNameMap(),
                conditionExpressions.getValueMap());
    }
    @Override
        return .deleteItem(spec);
    }

    
Updates the provisioned throughput for this table. Setting the throughput for a table helps you manage performance and is part of the provisioned throughput feature of DynamoDB.

The provisioned throughput values can be upgraded or downgraded based on the maximums and minimums listed in the Limits section in the Amazon DynamoDB Developer Guide.

This table must be in the ACTIVE state for this operation to succeed. UpdateTable is an asynchronous operation; while executing the operation, the table is in the UPDATING state. While the table is in the UPDATING state, the table still has the provisioned throughput from before the call. The new provisioned throughput setting is in effect only when the table returns to the ACTIVE state after the UpdateTable operation.

You can create, update or delete indexes using UpdateTable.

Parameters:
spec used to specify all the detailed parameters
Returns:
the updated table description returned from DynamoDB.
        UpdateTableRequest req = spec.getRequest();
        req.setTableName(getTableName());
        UpdateTableResult result = .updateTable(req);
        return this. = result.getTableDescription();
    }

    
Creates a global secondary index (GSI) with only a hash key on this table. Involves network calls. This table must be in the ACTIVE state for this operation to succeed. Creating a global secondary index is an asynchronous operation; while executing the operation, the index is in the CREATING state. Once created, the index will be in ACTIVE state.

Parameters:
create used to specify the details of the index creation
hashKeyDefinition used to specify the attribute for describing the key schema for the hash key of the GSI to be created for this table.
Returns:
the index being created
    public Index createGSI(
            CreateGlobalSecondaryIndexAction create,
            AttributeDefinition hashKeyDefinition) {
        return doCreateGSI(createhashKeyDefinition);
    }

    
Creates a global secondary index (GSI) with both a hash key and a range key on this table. Involves network calls. This table must be in the ACTIVE state for this operation to succeed. Creating a global secondary index is an asynchronous operation; while executing the operation, the index is in the CREATING state. Once created, the index will be in ACTIVE state.

Parameters:
create used to specify the details of the index creation
hashKeyDefinition used to specify the attribute for describing the key schema for the hash key of the GSI to be created for this table.
rangeKeyDefinition used to specify the attribute for describing the key schema for the range key of the GSI to be created for this table.
Returns:
the index being created
    public Index createGSI(
            CreateGlobalSecondaryIndexAction create,
            AttributeDefinition hashKeyDefinition,
            AttributeDefinition rangeKeyDefinition) {
        return doCreateGSI(createhashKeyDefinitionrangeKeyDefinition);
    }
    private Index doCreateGSI(
            CreateGlobalSecondaryIndexAction create,
            AttributeDefinition ... keyDefinitions) {
        UpdateTableSpec spec = new UpdateTableSpec()
            .withAttributeDefinitions(keyDefinitions)
            .withGlobalSecondaryIndexUpdates(
                new GlobalSecondaryIndexUpdate().withCreate(create))
            ;
        updateTable(spec);
        return this.getIndex(create.getIndexName());
    }

    
Updates the provisioned throughput for this table. Setting the throughput for a table helps you manage performance and is part of the provisioned throughput feature of DynamoDB.

The provisioned throughput values can be upgraded or downgraded based on the maximums and minimums listed in the Limits section in the Amazon DynamoDB Developer Guide.

This table must be in the ACTIVE state for this operation to succeed. UpdateTable is an asynchronous operation; while executing the operation, the table is in the UPDATING state. While the table is in the UPDATING state, the table still has the provisioned throughput from before the call. The new provisioned throughput setting is in effect only when the table returns to the ACTIVE state after the UpdateTable operation.

You can create, update or delete indexes using UpdateTable.

Parameters:
provisionedThroughput target provisioned throughput
Returns:
the updated table description returned from DynamoDB.
            ProvisionedThroughput provisionedThroughput) {
        return updateTable(new UpdateTableSpec()
            .withProvisionedThroughput(provisionedThroughput));
    }

    
A convenient blocking call that can be used, typically during table creation, to wait for the table to become active by polling the table every 5 seconds.

Returns:
the table description when the table has become active
Throws:
java.lang.IllegalArgumentException if the table is being deleted
com.amazonaws.services.dynamodbv2.model.ResourceNotFoundException if the table doesn't exist
        for (;;) {
            TableDescription desc = describe();
            String status = desc.getTableStatus();
            switch (TableStatus.fromValue(status)) {
                case :
                    return desc;
                case :
                case :
                    Thread.sleep();
                    continue;
                default:
                    throw new IllegalArgumentException("Table " + 
                        + " is not being created (with status=" + status + ")");
            }
        }
    }

    
A convenient blocking call that can be used, typically during table deletion, to wait for the table to become deleted by polling the table every 5 seconds.
    public void waitForDelete() throws InterruptedException {
        try {
            for (;;) {
                TableDescription desc = describe();
                String status = desc.getTableStatus();
                if (TableStatus.fromValue(status) == .) {
                    Thread.sleep();
                } else
                    throw new IllegalArgumentException("Table " + 
                        + " is not being deleted (with status=" + status + ")");
            }
        } catch(ResourceNotFoundException deleted) {
        }
        return;
    }

    
A convenient blocking call that can be used to wait on a table until it has either become active or deleted (ie no longer exists) by polling the table every 5 seconds.

Returns:
the table description if the table has become active; or null if the table has been deleted.
        try {
            for (;;) {
                TableDescription desc = describe();
                final String status = desc.getTableStatus();
                if (TableStatus.fromValue(status) == .)
                    return desc;
                else
                    Thread.sleep();
            }
        } catch(ResourceNotFoundException deleted) {
        }
        return null;
    }

    
A convenient blocking call that can be used to wait on a table and all it's indexes until both the table and it's indexes have either become active or deleted (ie no longer exists) by polling the table every 5 seconds.

Returns:
the table description if the table and all it's indexes have become active; or null if the table has been deleted.
        try {
            retry: for (;;) {
                TableDescription desc = describe();
                String status = desc.getTableStatus();
                if (TableStatus.fromValue(status) == .) {
                    List<GlobalSecondaryIndexDescriptiondescriptions =
                            desc.getGlobalSecondaryIndexes();
                        if (descriptions != null) {
                            for (GlobalSecondaryIndexDescription ddescriptions) {
                                status = d.getIndexStatus();
                                if (IndexStatus.fromValue(status) != .) {
                                    // Some index is not active.  Keep waiting.
                                    Thread.sleep();
                                    continue retry;
                                }
                            }
                        }
                        return desc;
                }
                Thread.sleep();
                continue;
            }
        } catch(ResourceNotFoundException deleted) {
        }
        return null;
    }

    
Deletes the table from DynamoDB. Involves network calls.
    public DeleteTableResult delete() {
        return .deleteTable();
    }
    @Override
    public Item getItem(KeyAttribute... primaryKeyComponents) {
        return .getItem(primaryKeyComponents);
    }
    @Override
    public Item getItem(PrimaryKey primaryKey) {
        return .getItem(primaryKey);
    }
    @Override
    public Item getItem(PrimaryKey primaryKeyString projectionExpression,
            Map<StringStringnameMap) {
        return .getItem(primaryKeyprojectionExpressionnameMap);
    }
    @Override
    public Item getItem(GetItemSpec spec) {
        return .getItem(spec);
    }
    @Override
    public GetItemOutcome getItemOutcome(String hashKeyNameObject hashKeyValue) {
        return .getItemOutcome(hashKeyNamehashKeyValue);
    }
    @Override
    public GetItemOutcome getItemOutcome(String hashKeyNameObject hashKeyValue,
            String rangeKeyNameObject rangeKeyValue) {
        return .getItemOutcome(hashKeyNamehashKeyValuerangeKeyNamerangeKeyValue);
    }
    @Override
    public Item getItem(String hashKeyNameObject hashKeyValue) {
        return .getItem(hashKeyNamehashKeyValue);
    }
    @Override
    public Item getItem(String hashKeyNameObject hashKeyValue,
            String rangeKeyNameObject rangeKeyValue) {
        return .getItem(hashKeyNamehashKeyValuerangeKeyNamerangeKeyValue);
    }
    @Override
    public ItemCollection<QueryOutcomequery(String hashKeyName,
            Object hashKeyValueRangeKeyCondition rangeKeyCondition) {
        return .query(hashKeyNamehashKeyValuerangeKeyCondition);
    }
    @Override
    public ItemCollection<QueryOutcomequery(String hashKeyName,
            Object hashKeyValueRangeKeyCondition rangeKeyCondition,
            QueryFilter... queryFilters) {
        return .query(hashKeyNamehashKeyValue,
                rangeKeyConditionqueryFilters);
    }
    @Override
    public ItemCollection<QueryOutcomequery(String hashKeyName,
            Object hashKeyValueRangeKeyCondition rangeKeyCondition,
            String filterExpressionMap<StringStringnameMap,
            Map<StringObjectvalueMap) {
        return .query(hashKeyNamehashKeyValue,
                rangeKeyConditionfilterExpressionnameMapvalueMap);
    }
    @Override
    public ItemCollection<QueryOutcomequery(String hashKeyName,
            Object hashKeyValueRangeKeyCondition rangeKeyCondition,
            String filterExpressionString projectionExpression,
            Map<StringStringnameMapMap<StringObjectvalueMap) {
        return .query(hashKeyNamehashKeyValue,
                rangeKeyConditionfilterExpressionprojectionExpression,
                nameMapvalueMap);
    }
    @Beta
    public ItemCollection<QueryOutcomequery(String hashKeyName,
            Object hashKeyValueRangeKeyCondition rangeKeyCondition,
            QueryExpressionSpec queryExpressions) {
        return .query(hashKeyNamehashKeyValuerangeKeyCondition,
                queryExpressions.getFilterExpression(),
                queryExpressions.getProjectionExpression(),
                queryExpressions.getNameMap(), queryExpressions.getValueMap());
    }
    @Override
    public UpdateItemOutcome updateItem(String hashKeyName,
            Object hashKeyValueAttributeUpdate... attributeUpdates) {
        return .updateItem(hashKeyNamehashKeyValue,
                attributeUpdates);
    }
    @Override
    public UpdateItemOutcome updateItem(String hashKeyName,
            Object hashKeyValueString rangeKeyNameObject rangeKeyValue,
            AttributeUpdate... attributeUpdates) {
        return .updateItem(hashKeyNamehashKeyValue,
                rangeKeyNamerangeKeyValueattributeUpdates);
    }
    @Override
    public UpdateItemOutcome updateItem(String hashKeyName,
            Object hashKeyValueCollection<Expectedexpected,
            AttributeUpdate... attributeUpdates) {
        return .updateItem(hashKeyNamehashKeyValue,
                expectedattributeUpdates);
    }
    @Override
    public UpdateItemOutcome updateItem(String hashKeyName,
            Object hashKeyValueString rangeKeyNameObject rangeKeyValue,
            Collection<ExpectedexpectedAttributeUpdate... attributeUpdates) {
        return .updateItem(hashKeyNamehashKeyValue,
                rangeKeyNamerangeKeyValue,
                expectedattributeUpdates);
    }
    @Override
    public UpdateItemOutcome updateItem(String hashKeyName,
            Object hashKeyValueString updateExpression,
            Map<StringStringnameMapMap<StringObjectvalueMap) {
        return .updateItem(hashKeyNamehashKeyValue,
                updateExpressionnameMapvalueMap);
    }
    @Override
    public UpdateItemOutcome updateItem(String hashKeyNameObject hashKeyValue,
            String rangeKeyNameObject rangeKeyValue,
            String updateExpression,
            Map<StringStringnameMap,
            Map<StringObjectvalueMap) {
        return .updateItem(hashKeyNamehashKeyValue,
                rangeKeyNamerangeKeyValue,
                updateExpressionnameMapvalueMap);
    }
    @Override
    public UpdateItemOutcome updateItem(String hashKeyNameObject hashKeyValue,
            String updateExpressionString conditionExpression,
            Map<StringStringnameMapMap<StringObjectvalueMap) {
        return .updateItem(hashKeyNamehashKeyValue,
                updateExpressionconditionExpression,
                nameMapvalueMap);
    }
    @Beta
    public UpdateItemOutcome updateItem(String hashKeyNameObject hashKeyValue,
            UpdateItemExpressionSpec updateExpressions) {
        return .updateItem(hashKeyNamehashKeyValue,
                    updateExpressions.getUpdateExpression(),
                    updateExpressions.getConditionExpression(),
                    updateExpressions.getNameMap(),
                    updateExpressions.getValueMap());
    }
    @Override
    public UpdateItemOutcome updateItem(String hashKeyNameObject hashKeyValue,
            String rangeKeyNameObject rangeKeyValue,
            String updateExpressionString conditionExpression,
            Map<StringStringnameMapMap<StringObjectvalueMap) {
        return .updateItem(hashKeyNamehashKeyValue,
                rangeKeyNamerangeKeyValue,
                updateExpressionconditionExpression,
                nameMapvalueMap);
    }
   @Beta
   public UpdateItemOutcome updateItem(String hashKeyNameObject hashKeyValue,
            String rangeKeyNameObject rangeKeyValue,
            UpdateItemExpressionSpec updateExpressions) {
        return .updateItem(
            hashKeyNamehashKeyValuerangeKeyNamerangeKeyValue,
            updateExpressions.getUpdateExpression(),
            updateExpressions.getConditionExpression(),
            updateExpressions.getNameMap(),
            updateExpressions.getValueMap());
    }
    @Override
    public GetItemOutcome getItemOutcome(String hashKeyName,
            Object hashKeyValueString projectionExpression,
            Map<StringStringnameMap) {
        return .getItemOutcome(hashKeyNamehashKeyValue,
                projectionExpressionnameMap);
    }
    @Override
    public GetItemOutcome getItemOutcome(String hashKeyName,
            Object hashKeyValueString rangeKeyNameObject rangeKeyValue,
            String projectionExpressionMap<StringStringnameMap) {
        return .getItemOutcome(hashKeyNamehashKeyValue,
                rangeKeyNamerangeKeyValueprojectionExpressionnameMap);
    }
    @Beta
    public GetItemOutcome getItemOutcome(String hashKeyName,
            Object hashKeyValueString rangeKeyNameObject rangeKeyValue,
            GetItemExpressionSpec projectionExpressions) {
        return .getItemOutcome(hashKeyNamehashKeyValue,
                rangeKeyNamerangeKeyValue,
                projectionExpressions.getProjectionExpression(),
                projectionExpressions.getNameMap());
    }
    @Override
    public Item getItem(String hashKeyNameObject hashKeyValue,
            String projectionExpressionMap<StringStringnameMap) {
        return .getItem(hashKeyNamehashKeyValue,
                projectionExpressionnameMap);
    }
    @Override
    public Item getItem(String hashKeyNameObject hashKeyValue,
            String rangeKeyNameObject rangeKeyValue,
            String projectionExpressionMap<StringStringnameMap) {
        return .getItem(hashKeyNamehashKeyValue,
                rangeKeyNamerangeKeyValueprojectionExpressionnameMap);
    }
    @Beta
    public Item getItem(String hashKeyNameObject hashKeyValue,
            String rangeKeyNameObject rangeKeyValue,
            GetItemExpressionSpec projectionExpressions) {
        return .getItem(hashKeyNamehashKeyValuerangeKeyName,
                rangeKeyValueprojectionExpressions.getProjectionExpression(),
                projectionExpressions.getNameMap());
        
    }
    @Override
    public DeleteItemOutcome deleteItem(String hashKeyNameObject hashKeyValue) {
        return .deleteItem(hashKeyNamehashKeyValue);
    }
    @Override
    public DeleteItemOutcome deleteItem(String hashKeyName,
            Object hashKeyValueString rangeKeyNameObject rangeKeyValue) {
        return .deleteItem(hashKeyNamehashKeyValue,
                rangeKeyNamerangeKeyValue);
    }
    @Override
    public DeleteItemOutcome deleteItem(String hashKeyName,
            Object hashKeyValueExpected... expected) {
        return .deleteItem(hashKeyNamehashKeyValue,
                expected);
    }
    @Override
    public DeleteItemOutcome deleteItem(String hashKeyName,
            Object hashKeyValueString rangeKeyNameObject rangeKeyValue,
            Expected... expected) {
        return .deleteItem(hashKeyNamehashKeyValue,
                rangeKeyNamerangeKeyValueexpected);
    }
    @Override
    public DeleteItemOutcome deleteItem(String hashKeyName,
            Object hashKeyValueString conditionExpression,
            Map<StringStringnameMapMap<StringObjectvalueMap) {
        return .deleteItem(hashKeyNamehashKeyValue,
                conditionExpression,  nameMapvalueMap);
    }
    @Override
    public DeleteItemOutcome deleteItem(String hashKeyName,
            Object hashKeyValueString rangeKeyNameObject rangeKeyValue,
            String conditionExpressionMap<StringStringnameMap,
            Map<StringObjectvalueMap) {
        return .deleteItem(hashKeyNamehashKeyValue,
                rangeKeyNamerangeKeyValue,
                conditionExpression,  nameMapvalueMap);
    }
    @Beta
    public DeleteItemOutcome deleteItem(String hashKeyName,
            Object hashKeyValueString rangeKeyNameObject rangeKeyValue,
            DeleteItemExpressionSpec conditionExpressions) {
        return .deleteItem(hashKeyNamehashKeyValue,
                rangeKeyNamerangeKeyValue,
                conditionExpressions.getConditionExpression(),
                conditionExpressions.getNameMap(),
                conditionExpressions.getValueMap());
    }
    @Override
    public String toString() {
        return "{" +  + ": " +  + "}";
    }
New to GrepCode? Check out our FAQ X