DeleteItemResult deleteItem(final DeleteItemRequest request) throws BackendException {
    setUserAgent(request);
    DeleteItemResult result;
    final int wcu = estimateCapacityUnits(DELETE_ITEM, request.getTableName());
    timedWriteThrottle(DELETE_ITEM, request.getTableName(), wcu);

    final Timer.Context apiTimerContext = getTimerContext(DELETE_ITEM, request.getTableName());
    try {
        result = client.deleteItem(request);
    } catch (Exception e) {
        throw processDynamoDbApiException(e, DELETE_ITEM, request.getTableName());
    } finally {
        apiTimerContext.stop();
    }
    meterConsumedCapacity(DELETE_ITEM, result.getConsumedCapacity());

    return result;
}
 

private Collection<MutateWorker> createWorkersForDeletions(final StaticBuffer hashKey, final List<StaticBuffer> deletions, final DynamoDbStoreTransaction txh) {
    final List<MutateWorker> workers = new LinkedList<>();
    for (StaticBuffer rangeKey : deletions) {
        final Map<String, AttributeValue> keys = new ItemBuilder().hashKey(hashKey)
                                                                  .rangeKey(rangeKey)
                                                                  .build();

        final Expression updateExpression = new MultiUpdateExpressionBuilder(this, txh).hashKey(hashKey)
                                                                              .rangeKey(rangeKey)
                                                                              .build();

        final DeleteItemRequest request = super.createDeleteItemRequest().withKey(keys)
                 .withConditionExpression(updateExpression.getConditionExpression())
                 .withExpressionAttributeValues(updateExpression.getAttributeValues());


        workers.add(new DeleteItemWorker(request, client.getDelegate()));
    }
    return workers;
}
 

@Override
public Void call() throws BackendException {

    final UpdateItem updateBackoff = new UpdateItem(updateItemRequest, dynamoDbDelegate);
    final UpdateItemResult result = updateBackoff.runWithBackoff();


    final Map<String, AttributeValue> item = result.getAttributes();

    if (item == null) {
        // bail
        return null;
    }

    // If the record has no Titan columns left after deletions occur, then just delete the record
    if (item.containsKey(Constants.JANUSGRAPH_HASH_KEY) && item.size() == ATTRIBUTES_IN_EMPTY_SINGLE_ITEM) {
        final DeleteItem deleteBackoff = new DeleteItem(new DeleteItemRequest().withTableName(updateItemRequest.getTableName())
                                                                         .withKey(updateItemRequest.getKey()), dynamoDbDelegate);
        deleteBackoff.runWithBackoff();
    }

    // void
    return null;
}
 

/**
 * Creates a DynamoDB write request based on the DynamoDB Stream record.
 *
 * @param record
 *            The DynamoDB Stream record containing information about the update to a DynamoDB table
 * @return A DynamoDB request based on the DynamoDB Stream record
 */
private AmazonWebServiceRequest createRequest(final Record record) {
    final String eventName = record.getEventName();
    final AmazonWebServiceRequest request;
    if (eventName.equalsIgnoreCase(OperationType.INSERT.toString()) || eventName.equalsIgnoreCase(OperationType.MODIFY.toString())) {
        // For INSERT or MODIFY: Put the new image in the DynamoDB table
        PutItemRequest putItemRequest = new PutItemRequest();
        putItemRequest.setItem(record.getDynamodb().getNewImage());
        putItemRequest.setTableName(getTableName());
        request = putItemRequest;
    } else if (eventName.equalsIgnoreCase(OperationType.REMOVE.toString())) {
        // For REMOVE: Delete the item from the DynamoDB table
        DeleteItemRequest deleteItemRequest = new DeleteItemRequest();
        deleteItemRequest.setKey(record.getDynamodb().getKeys());
        deleteItemRequest.setTableName(getTableName());
        request = deleteItemRequest;
    } else {
        // This should only happen if DynamoDB Streams adds/changes its operation types
        log.warn("Unsupported operation type detected: " + eventName + ". Record: " + record);
        request = null;
    }
    if (null != request) {
        request.getRequestClientOptions().appendUserAgent(USER_AGENT);
    }
    return request;
}
 

@SuppressWarnings("deprecation")
@Test
public void removeTest() throws Exception {
    // Set up the buffer and do sanity checks
    buffer.clear();
    buffer.consumeRecord(ITEM1_REMOVE, ITEM1_REMOVE.getDynamodb().getSizeBytes().intValue(), ITEM1_REMOVE.getDynamodb().getSequenceNumber());
    assertEquals(ITEM1_REMOVE.getDynamodb().getSequenceNumber(), buffer.getFirstSequenceNumber());
    assertEquals(ITEM1_REMOVE.getDynamodb().getSequenceNumber(), buffer.getLastSequenceNumber());
    List<Record> buffered = buffer.getRecords();
    assertEquals(1, buffered.size());
    assertTrue(buffered.contains(ITEM1_REMOVE));

    // Emit record
    resetAll(DYNAMODB);
    DYNAMODB.deleteItemAsync(anyObject(DeleteItemRequest.class), anyObject(AsyncHandler.class));
    expectLastCall().andAnswer(SUCCESS_ANSWER);
    expectNew(AmazonDynamoDBAsyncClient.class, new Class<?>[] {AWSCredentialsProvider.class, ClientConfiguration.class, ExecutorService.class}, anyObject(AWSCredentialsProvider.class), anyObject(ClientConfiguration.class), anyObject(ExecutorService.class)).andReturn(DYNAMODB);
    DYNAMODB.setEndpoint(EasyMock.anyString());
    EasyMock.expectLastCall().anyTimes();
    replayAll(DYNAMODB);
    IEmitter<Record> instance = createEmitterInstance();
    assertTrue(instance.emit(new UnmodifiableBuffer<Record>(buffer)).isEmpty());
    verifyAll();
}
 

public DeletePointResult deletePoint(DeletePointRequest deletePointRequest) {
	long geohash = S2Manager.generateGeohash(deletePointRequest.getGeoPoint());
	long hashKey = S2Manager.generateHashKey(geohash, config.getHashKeyLength());

	DeleteItemRequest deleteItemRequest = deletePointRequest.getDeleteItemRequest();

	deleteItemRequest.setTableName(config.getTableName());

	AttributeValue hashKeyValue = new AttributeValue().withN(String.valueOf(hashKey));
	deleteItemRequest.getKey().put(config.getHashKeyAttributeName(), hashKeyValue);
	deleteItemRequest.getKey().put(config.getRangeKeyAttributeName(), deletePointRequest.getRangeKeyValue());

	DeleteItemResult deleteItemResult = config.getDynamoDBClient().deleteItem(deleteItemRequest);
	DeletePointResult deletePointResult = new DeletePointResult(deleteItemResult);

	return deletePointResult;
}
 

@Test
public void getItemWithDelete() {
    Transaction t1 = manager.newTransaction();
    Map<String, AttributeValue> getResult1 = t1.getItem(new GetItemRequest().withTableName(INTEG_HASH_TABLE_NAME).withKey(key0)).getItem();
    assertEquals(getResult1, item0);
    assertItemLocked(INTEG_HASH_TABLE_NAME, key0, item0, t1.getId(), false, false);
    
    t1.deleteItem(new DeleteItemRequest().withTableName(INTEG_HASH_TABLE_NAME).withKey(key0));
    assertItemLocked(INTEG_HASH_TABLE_NAME, key0, item0, t1.getId(), false, false);
    
    Map<String, AttributeValue> getResult2 = t1.getItem(new GetItemRequest().withTableName(INTEG_HASH_TABLE_NAME).withKey(key0)).getItem();
    assertNull(getResult2);
    assertItemLocked(INTEG_HASH_TABLE_NAME, key0, item0, t1.getId(), false, false);
    
    t1.commit();
}
 

@Test
public void getItemUncommittedDeleted() {
    Transaction t1 = manager.newTransaction();
    
    t1.deleteItem(new DeleteItemRequest()
        .withTableName(INTEG_HASH_TABLE_NAME)
        .withKey(key0));
    
    assertItemLocked(INTEG_HASH_TABLE_NAME, key0, item0, t1.getId(), false, false);
    
    Map<String, AttributeValue> item = manager.getItem(new GetItemRequest()
        .withTableName(INTEG_HASH_TABLE_NAME)
        .withKey(key0), IsolationLevel.UNCOMMITTED).getItem();
    assertNoSpecialAttributes(item);
    assertEquals(item0, item);
    assertItemLocked(INTEG_HASH_TABLE_NAME, key0, item0, t1.getId(), false, false);
    
    t1.rollback();
}
 

@Test
public void getItemCommittedDeleted() {
    Transaction t1 = manager.newTransaction();
    
    t1.deleteItem(new DeleteItemRequest()
        .withTableName(INTEG_HASH_TABLE_NAME)
        .withKey(key0));
    
    assertItemLocked(INTEG_HASH_TABLE_NAME, key0, item0, t1.getId(), false, false);
    
    Map<String, AttributeValue> item = manager.getItem(new GetItemRequest()
        .withTableName(INTEG_HASH_TABLE_NAME)
        .withKey(key0), IsolationLevel.COMMITTED).getItem();
    assertNoSpecialAttributes(item);
    assertEquals(item0, item);
    assertItemLocked(INTEG_HASH_TABLE_NAME, key0, item0, t1.getId(), false, false);
    
    t1.rollback();
}
 

@Test
public void deleteItemAllOldNotExists() {
    Transaction t1 = manager.newTransaction();
    Map<String, AttributeValue> key1 = newKey(INTEG_HASH_TABLE_NAME);
    
    Map<String, AttributeValue> result1 = t1.deleteItem(new DeleteItemRequest()
        .withTableName(INTEG_HASH_TABLE_NAME)
        .withKey(key1)
        .withReturnValues(ReturnValue.ALL_OLD)).getAttributes();
    assertItemLocked(INTEG_HASH_TABLE_NAME, key1, key1, t1.getId(), true, false);
    assertNull(result1);
    
    t1.commit();
    
    assertItemNotLocked(INTEG_HASH_TABLE_NAME, key1, false);
}
 

@Override
public void processRecords(ProcessRecordsInput processRecordsInput) {
    for (Record record : processRecordsInput.getRecords()) {
        String data = new String(record.getData().array(), Charset.forName("UTF-8"));
        System.out.println(data);
        if (record instanceof RecordAdapter) {
            com.amazonaws.services.dynamodbv2.model.Record streamRecord = ((RecordAdapter) record)
                    .getInternalObject();

            switch (streamRecord.getEventName()) {
                case "INSERT": case "MODIFY":
                    Map<String, AttributeValue> items = streamRecord.getDynamodb().getNewImage();
                    PutItemRequest putItemRequest = new PutItemRequest().withTableName(tableName).withItem(items);
                    dynamoDBClient.putItem(putItemRequest);
                    break;
                case "REMOVE":
                    Map<String, AttributeValue> keys = streamRecord.getDynamodb().getKeys();
                    DeleteItemRequest deleteItemRequest = new DeleteItemRequest().withTableName(tableName).withKey(keys);
                    dynamoDBClient.deleteItem(deleteItemRequest);
            }
        }
        checkpointCounter += 1;
        if (checkpointCounter % 10 == 0) {
            try {
                processRecordsInput.getCheckpointer().checkpoint();
            }
            catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

}
 

private static void deleteItem() {
    try {

        HashMap<String, AttributeValue> key = new HashMap<String, AttributeValue>();
        key.put("Id", new AttributeValue().withN("120"));

        Map<String, AttributeValue> expressionAttributeValues = new HashMap<String, AttributeValue>();
        expressionAttributeValues.put(":val", new AttributeValue().withBOOL(false));

        ReturnValue returnValues = ReturnValue.ALL_OLD;

        DeleteItemRequest deleteItemRequest = new DeleteItemRequest().withTableName(tableName).withKey(key)
            .withConditionExpression("InPublication = :val")
            .withExpressionAttributeValues(expressionAttributeValues).withReturnValues(returnValues);

        DeleteItemResult result = client.deleteItem(deleteItemRequest);

        // Check the response.
        System.out.println("Printing item that was deleted...");
        printItem(result.getAttributes());

    }
    catch (AmazonServiceException ase) {
        System.err.println("Failed to get item after deletion " + tableName);
    }

}
 

public static void deleteItem(String threadId, String replyDateTime) {
    HashMap<String, AttributeValue> key = new HashMap<String, AttributeValue>();
    key.put("Id", new AttributeValue().withS(threadId));
    key.put("ReplyDateTime", new AttributeValue().withS(replyDateTime));

    DeleteItemRequest deleteReplyRequest = new DeleteItemRequest().withTableName(tableName).withKey(key);
    client.deleteItem(deleteReplyRequest);
}
 

public static void deleteItem(AmazonDynamoDB dynamoDBClient, String tableName, String id) {
    java.util.Map<String, AttributeValue> key = new HashMap<String, AttributeValue>();
    key.put("Id", new AttributeValue().withN(id));

    DeleteItemRequest deleteItemRequest = new DeleteItemRequest().withTableName(tableName).withKey(key);
    dynamoDBClient.deleteItem(deleteItemRequest);
}
 

/**
 * Deletes the specified username from the identity table.
 * 
 * @param username
 *            Unique user identifier
 * @throws DataAccessException
 */
public void deleteUser(String username) throws DataAccessException {
    HashMap<String, AttributeValue> key = new HashMap<String, AttributeValue>();
    key.put(ATTRIBUTE_USERNAME, new AttributeValue().withS(username));

    DeleteItemRequest deleteItemRequest = new DeleteItemRequest()
            .withTableName(USER_TABLE)
            .withKey(key);

    try {
        ddb.deleteItem(deleteItemRequest);
    } catch (AmazonClientException e) {
        throw new DataAccessException("Failed to delete user: " + username, e);
    }
}
 

/**
 * Deletes the specified UID from the identity table.
 * 
 * @param uid
 *            Unique device identifier
 */
public void deleteDevice(String uid) throws DataAccessException {
    HashMap<String, AttributeValue> key = new HashMap<String, AttributeValue>();
    key.put(ATTRIBUTE_UID, new AttributeValue().withS(uid));

    DeleteItemRequest deleteItemRequest = new DeleteItemRequest()
            .withTableName(DEVICE_TABLE)
            .withKey(key);

    try {
        ddb.deleteItem(deleteItemRequest);
    } catch (AmazonClientException e) {
        throw new DataAccessException("Failed to delete device: " + uid, e);
    }
}
 

/**
 * Deletes the specified UID from the identity table.
 * 
 * @param uid
 *            Unique device identifier
 */
public void deleteDevice(String uid) throws DataAccessException {
    HashMap<String, AttributeValue> key = new HashMap<String, AttributeValue>();
    key.put(ATTRIBUTE_UID, new AttributeValue().withS(uid));

    DeleteItemRequest deleteItemRequest = new DeleteItemRequest()
            .withTableName(DEVICE_TABLE)
            .withKey(key);

    try {
        ddb.deleteItem(deleteItemRequest);
    } catch (AmazonClientException e) {
        throw new DataAccessException("Failed to delete device: " + uid, e);
    }
}
 

/**
 * Deletes the specified username from the identity table.
 * 
 * @param username
 *            Unique user identifier
 * @throws DataAccessException
 */
public void deleteUser(String username) throws DataAccessException {
    HashMap<String, AttributeValue> key = new HashMap<String, AttributeValue>();
    key.put(ATTRIBUTE_USERNAME, new AttributeValue().withS(username));

    DeleteItemRequest deleteItemRequest = new DeleteItemRequest()
            .withTableName(USER_TABLE)
            .withKey(key);

    try {
        ddb.deleteItem(deleteItemRequest);
    } catch (AmazonClientException e) {
        throw new DataAccessException("Failed to delete user: " + username, e);
    }
}
 

/**
 * Deletes the specified username from the user table.
 */
public void deleteUser(String username, String table) {
    HashMap<String, AttributeValue> key = new HashMap<String, AttributeValue>();
    key.put("username", new AttributeValue().withS(username));

    DeleteItemRequest deleteItemRequest = new DeleteItemRequest()
            .withTableName(table)
            .withKey(key);

    ddb.deleteItem(deleteItemRequest);
}
 

/**
 * Deletes the specified UID from the identity table.
 * 
 * @param uid
 *            Unique device identifier
 */
public void deleteDevice(String uid) throws DataAccessException {
    HashMap<String, AttributeValue> key = new HashMap<String, AttributeValue>();
    key.put(ATTRIBUTE_UID, new AttributeValue().withS(uid));

    DeleteItemRequest deleteItemRequest = new DeleteItemRequest()
            .withTableName(DEVICE_TABLE)
            .withKey(key);

    try {
        ddb.deleteItem(deleteItemRequest);
    } catch (AmazonClientException e) {
        throw new DataAccessException("Failed to delete device: " + uid, e);
    }
}
 

private static void deleteItem() {
    try {
        
        HashMap<String, AttributeValue> key = new HashMap<String, AttributeValue>();
        key.put("Id", new AttributeValue().withN("120"));

        Map<String, AttributeValue> expressionAttributeValues = new HashMap<String, AttributeValue>();
        expressionAttributeValues.put(":val", new AttributeValue().withBOOL(false)); 
 
        ReturnValue returnValues = ReturnValue.ALL_OLD;

        DeleteItemRequest deleteItemRequest = new DeleteItemRequest()
            .withTableName(tableName)
            .withKey(key)
            .withConditionExpression("InPublication = :val")
            .withExpressionAttributeValues(expressionAttributeValues)
            .withReturnValues(returnValues);

        DeleteItemResult result = client.deleteItem(deleteItemRequest);
        
        // Check the response.
        System.out.println("Printing item that was deleted...");
        printItem(result.getAttributes());            

                                
    } catch (AmazonServiceException ase) {
        System.err.println("Failed to get item after deletion " + tableName);
    } 
    
}
 

public static void deleteItem(String threadId, String replyDateTime) {
    HashMap<String, AttributeValue> key = new HashMap<String, AttributeValue>();
    key.put("Id", new AttributeValue().withS(threadId));
    key.put("ReplyDateTime", new AttributeValue().withS(replyDateTime));

    DeleteItemRequest deleteReplyRequest = new DeleteItemRequest()
        .withTableName(tableName)
        .withKey(key);
    client.deleteItem(deleteReplyRequest);
}
 

public static void deleteItem(AmazonDynamoDBClient client, String tableName, String id) {
    java.util.Map<String, AttributeValue> key = new HashMap<String, AttributeValue>();
    key.put("Id", new AttributeValue().withN(id));

    DeleteItemRequest deleteItemRequest = new DeleteItemRequest()
        .withTableName(tableName)
        .withKey(key);
    client.deleteItem(deleteItemRequest);
}
 

public DeletePointRequest(GeoPoint geoPoint, AttributeValue rangeKeyValue) {
	deleteItemRequest = new DeleteItemRequest();
	deleteItemRequest.setKey(new HashMap<String, AttributeValue>());

	this.geoPoint = geoPoint;
	this.rangeKeyValue = rangeKeyValue;
}
 

@After
public void teardown() {
    Transaction t = manager.newTransaction();
    t.deleteItem(new DeleteItemRequest().withTableName(INTEG_HASH_TABLE_NAME).withKey(key0));
    t.commit();
    assertItemNotLocked(INTEG_HASH_TABLE_NAME, key0, false);
}
 

@After
public void teardown() {
    dynamodb.reset();
    Transaction t = manager.newTransaction();
    t.deleteItem(new DeleteItemRequest().withTableName(INTEG_HASH_TABLE_NAME).withKey(key0));
    t.commit();
    assertItemNotLocked(INTEG_HASH_TABLE_NAME, key0, false);
}
 

@Test
public void phantomItemFromDelete() {
    Map<String, AttributeValue> key1 = newKey(INTEG_HASH_TABLE_NAME);
    Transaction transaction = manager.newTransaction();
    DeleteItemRequest deleteRequest = new DeleteItemRequest()
        .withTableName(INTEG_HASH_TABLE_NAME)
        .withKey(key1);
    transaction.deleteItem(deleteRequest);
    assertItemLocked(INTEG_HASH_TABLE_NAME, key1, transaction.getId(), true, false);
    transaction.rollback();
    assertItemNotLocked(INTEG_HASH_TABLE_NAME, key1, false);
    transaction.delete(Long.MAX_VALUE);
}
 

@Test
public void lockItem() {
    Map<String, AttributeValue> key1 = newKey(INTEG_HASH_TABLE_NAME);
    Transaction t1 = manager.newTransaction();
    Transaction t2 = manager.newTransaction();
    
    DeleteItemRequest deleteRequest = new DeleteItemRequest()
        .withTableName(INTEG_HASH_TABLE_NAME)
        .withKey(key1);
    
    GetItemRequest lockRequest = new GetItemRequest()
        .withTableName(INTEG_HASH_TABLE_NAME)
        .withKey(key1);
    
    Map<String, AttributeValue> getResult = t1.getItem(lockRequest).getItem();
    
    assertItemLocked(INTEG_HASH_TABLE_NAME, key1, t1.getId(), true, false); // we're not applying locks
    assertNull(getResult);

    Map<String, AttributeValue> deleteResult = t2.deleteItem(deleteRequest).getAttributes();
    assertItemLocked(INTEG_HASH_TABLE_NAME, key1, t2.getId(), true, false); // we're not applying deletes either
    assertNull(deleteResult); // return values is null in the request
    
    t2.commit();
    
    try {
        t1.commit();
        fail();
    } catch (TransactionRolledBackException e) { }
    
    t1.delete(Long.MAX_VALUE);
    t2.delete(Long.MAX_VALUE);
    
    assertItemNotLocked(INTEG_HASH_TABLE_NAME, key1, false);
}
 

@Test
public void deleteItemAllOldExists() {
    Transaction t1 = manager.newTransaction();
    
    Map<String, AttributeValue> result1 = t1.deleteItem(new DeleteItemRequest()
        .withTableName(INTEG_HASH_TABLE_NAME)
        .withKey(key0)
        .withReturnValues(ReturnValue.ALL_OLD)).getAttributes();
    assertItemLocked(INTEG_HASH_TABLE_NAME, key0, item0, t1.getId(), false, false);
    assertEquals(item0, result1);
    
    t1.commit();
    
    assertItemNotLocked(INTEG_HASH_TABLE_NAME, key0, false);
}
 

/**
 * Adds a DeleteItem request to the transaction
 * 
 * @param request
 * @throws DuplicateRequestException if the item in the request is already involved in this transaction
 * @throws ItemNotLockedException when another transaction is confirmed to have the lock on the item in the request
 * @throws TransactionCompletedException when the transaction has already completed
 * @throws TransactionNotFoundException if the transaction does not exist
 * @throws TransactionException on unexpected errors or unresolvable OCC contention
 */
public DeleteItemResult deleteItem(DeleteItemRequest request) 
    throws DuplicateRequestException, ItemNotLockedException, 
        TransactionCompletedException, TransactionNotFoundException, TransactionException {
    
    DeleteItem wrappedRequest = new DeleteItem();
    wrappedRequest.setRequest(request);
    Map<String, AttributeValue> item = driveRequest(wrappedRequest);
    stripSpecialAttributes(item);
    return new DeleteItemResult().withAttributes(item);
}