Java DeleteItemRequest类代码示例

import com.amazonaws.services.dynamodbv2.model.DeleteItemRequest; //导入依赖的package包/类
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;
}
 

import com.amazonaws.services.dynamodbv2.model.DeleteItemRequest; //导入依赖的package包/类
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;
}
 

import com.amazonaws.services.dynamodbv2.model.DeleteItemRequest; //导入依赖的package包/类
@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;
}
 

import com.amazonaws.services.dynamodbv2.model.DeleteItemRequest; //导入依赖的package包/类
@Override
public <T extends Message> boolean delete(T item, Modifier... modifiers) throws DataStoreException {
  DynamoClassMapping<T> tableInfo = getClassMapping(item);

  log.debug("Delete {}", item);

  for (Modifier modifier : modifiers) {
    throw new UnsupportedOperationException();
  }

  DeleteItemRequest request = new DeleteItemRequest();
  request.setTableName(tableInfo.getDynamoTableName());
  request.setKey(tableInfo.buildCompleteKey(item));
  request.setConditionExpression("attribute_exists(hash_key)");
  try {
    DeleteItemResult response = dynamoDB.deleteItem(request);
    return true;
  } catch (ConditionalCheckFailedException e) {
    return false;
  }
}
 

import com.amazonaws.services.dynamodbv2.model.DeleteItemRequest; //导入依赖的package包/类
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;
}
 

import com.amazonaws.services.dynamodbv2.model.DeleteItemRequest; //导入依赖的package包/类
/**
 * Delete.
 *
 * @param ticketId the ticket id
 * @return the boolean
 */
public boolean delete(final String ticketId) {
    final TicketDefinition metadata = this.ticketCatalog.find(ticketId);
    if (metadata != null) {
        final DeleteItemRequest del = new DeleteItemRequest()
                .withTableName(metadata.getProperties().getStorageName())
                .withKey(Collections.singletonMap(ColumnNames.ID.getName(), new AttributeValue(ticketId)));

        LOGGER.debug("Submitting delete request [{}] for ticket [{}]", del, ticketId);
        final DeleteItemResult res = amazonDynamoDBClient.deleteItem(del);
        LOGGER.debug("Delete request came back with result [{}]", res);
        return res != null;
    }
    return false;
}
 

import com.amazonaws.services.dynamodbv2.model.DeleteItemRequest; //导入依赖的package包/类
/**
 * Delete boolean.
 *
 * @param service the service
 * @return the boolean
 */
public boolean delete(final RegisteredService service) {
    final DeleteItemRequest del = new DeleteItemRequest()
            .withTableName(TABLE_NAME)
            .withKey(Collections.singletonMap(ColumnNames.ID.getName(), new AttributeValue(String.valueOf(service.getId()))));

    LOGGER.debug("Submitting delete request [{}] for service [{}]", del, service);
    final DeleteItemResult res = amazonDynamoDBClient.deleteItem(del);
    LOGGER.debug("Delete request came back with result [{}]", res);
    return res != null;

}
 

import com.amazonaws.services.dynamodbv2.model.DeleteItemRequest; //导入依赖的package包/类
public CompletableFuture<DeleteItemResult> deleteItem(final DeleteItemRequest deleteItemRequest) {
    return asyncExecutor.execute(new Callable<DeleteItemResult>() {
        @Override
        public DeleteItemResult call() throws Exception {
            return dbExecutor.deleteItem(deleteItemRequest);
        }
    });
}
 

import com.amazonaws.services.dynamodbv2.model.DeleteItemRequest; //导入依赖的package包/类
@Override
public void execute() {
    DeleteItemResult result = ddbClient.deleteItem(new DeleteItemRequest()
            .withTableName(determineTableName())
            .withKey(determineKey())
            .withReturnValues(determineReturnValues())
            .withExpected(determineUpdateCondition()));

    addAttributesToResult(result.getAttributes());
}
 

import com.amazonaws.services.dynamodbv2.model.DeleteItemRequest; //导入依赖的package包/类
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);
}
 

import com.amazonaws.services.dynamodbv2.model.DeleteItemRequest; //导入依赖的package包/类
/**
 * 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);
    }
}
 

import com.amazonaws.services.dynamodbv2.model.DeleteItemRequest; //导入依赖的package包/类
/**
 * 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);
    }
}
 

import com.amazonaws.services.dynamodbv2.model.DeleteItemRequest; //导入依赖的package包/类
@Override
public DeleteItemResult deleteItem(String tableName, HashMap<String, AttributeValue> primaryKey) {
    DeleteItemRequest deleteItemRequest = new DeleteItemRequest()
        .withTableName(tableName)
        .withKey(primaryKey);
        
    DeleteItemResult deleteItemResult = dynamoDBClient.deleteItem(deleteItemRequest);
    LOG.info("Successful by deleting item in " + tableName);
    return deleteItemResult;
}
 

import com.amazonaws.services.dynamodbv2.model.DeleteItemRequest; //导入依赖的package包/类
private void deleteRow(String key, String appid) {
	if (StringUtils.isBlank(key) || StringUtils.isBlank(appid)) {
		return;
	}
	try {
		DeleteItemRequest delItemRequest = new DeleteItemRequest(getTableNameForAppid(appid),
				Collections.singletonMap(Config._KEY, new AttributeValue(getKeyForAppid(key, appid))));
		client().deleteItem(delItemRequest);
	} catch (Exception e) {
		logger.error("Could not delete row from DB - appid={}, key={}", appid, key, e);
	}
}
 

import com.amazonaws.services.dynamodbv2.model.DeleteItemRequest; //导入依赖的package包/类
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);
    } 
    
}