Java 类com.amazonaws.services.dynamodbv2.model.DeleteItemResult 实例源码

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;
}

@Test
public void test_deleteItem_WithAllParameters() throws Exception {
  createTable();
  putItem(TEST_ATTRIBUTE, TEST_ATTRIBUTE_VALUE);

  Map<String, AttributeValue> key = new HashMap<String, AttributeValue>();
  key.put(TEST_ATTRIBUTE, new AttributeValue()
    .withS(TEST_ATTRIBUTE_VALUE));
  String returnValues = "";

  DeleteItemResult deleteResult = dynamoDb.deleteItem(TEST_TABLE_NAME, key, returnValues);
  AttributeValue attributeValue = deleteResult.getAttributes().get(TEST_ATTRIBUTE);

  GetItemResult getResult = getItem(TEST_ATTRIBUTE, TEST_ATTRIBUTE_VALUE);

  assertThat(attributeValue.getS(), equalTo(TEST_ATTRIBUTE_VALUE));
  assertThat(getResult, nullValue());
}

/**
 * The deleteEntityByUniqueId method deletes an item from a table.
 * 
 * @param uniqueId
 * @return
 */
@Override
public boolean deleteEntityByUniqueId(String tableName, String uniqueId) {
    if (StringUtils.isEmpty(uniqueId)) {
        return false;
    }

    HashMap<String, AttributeValue> primaryKey = new HashMap<String, AttributeValue> ();
    primaryKey.put(AttributeKey.UUID, new AttributeValue().withS(uniqueId));
    DeleteItemResult deleteItemResult = dynamoDBService.deleteItem(tableName, primaryKey);
    if (deleteItemResult != null) {
        return true;
    }

    return false;
}

@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;
  }
}

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;
}

/**
 * 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;
}

/**
 * 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;

}

public CompletableFuture<DeleteItemResult> deleteItem(final String tableName, final Map<String, AttributeValue> key) {
    return asyncExecutor.execute(new Callable<DeleteItemResult>() {
        @Override
        public DeleteItemResult call() throws Exception {
            return dbExecutor.deleteItem(tableName, key);
        }
    });
}

public CompletableFuture<DeleteItemResult> deleteItem(final String tableName, final Map<String, AttributeValue> key, final String returnValues) {
    return asyncExecutor.execute(new Callable<DeleteItemResult>() {
        @Override
        public DeleteItemResult call() throws Exception {
            return dbExecutor.deleteItem(tableName, key, returnValues);
        }
    });
}

public CompletableFuture<DeleteItemResult> deleteItem(final DeleteItemRequest deleteItemRequest) {
    return asyncExecutor.execute(new Callable<DeleteItemResult>() {
        @Override
        public DeleteItemResult call() throws Exception {
            return dbExecutor.deleteItem(deleteItemRequest);
        }
    });
}

@Override
public void execute() {
    DeleteItemResult result = ddbClient.deleteItem(new DeleteItemRequest()
            .withTableName(determineTableName())
            .withKey(determineKey())
            .withReturnValues(determineReturnValues())
            .withExpected(determineUpdateCondition()));

    addAttributesToResult(result.getAttributes());
}

@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;
}

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);
    } 

}

@Override
@SuppressWarnings("PMD.UseConcurrentHashMap")
public void remove() {
    synchronized (this.dosage) {
        final AmazonDynamoDB aws = this.credentials.aws();
        try {
            final Dosage prev = this.dosage.get();
            final List<Map<String, AttributeValue>> items =
                new ArrayList<Map<String, AttributeValue>>(prev.items());
            final Map<String, AttributeValue> item =
                items.remove(this.position);
            final long start = System.currentTimeMillis();
            final DeleteItemResult res = aws.deleteItem(
                new DeleteItemRequest()
                    .withTableName(this.name)
                    .withKey(new Attributes(item).only(this.keys))
                    .withReturnConsumedCapacity(
                        ReturnConsumedCapacity.TOTAL
                    )
                    .withExpected(
                        new Attributes(item).only(this.keys).asKeys()
                    )
            );
            this.dosage.set(new AwsIterator.Fixed(prev, items));
            --this.position;
            Logger.info(
                this,
                "#remove(): item #%d removed from DynamoDB, %s, in %[ms]s",
                this.position,
                new PrintableConsumedCapacity(
                    res.getConsumedCapacity()
                ).print(),
                System.currentTimeMillis() - start
            );
        } finally {
            aws.shutdown();
        }
    }
}

@Override
public void delete(final Map<String, AttributeValue> attributes)
    throws IOException {
    final AmazonDynamoDB aws = this.credentials.aws();
    try {
        final DeleteItemRequest request = new DeleteItemRequest();
        request.setTableName(this.self);
        request.setKey(attributes);
        request.setReturnValues(ReturnValue.NONE);
        request.setReturnConsumedCapacity(ReturnConsumedCapacity.TOTAL);
        final DeleteItemResult result = aws.deleteItem(request);
        final long start = System.currentTimeMillis();
        Logger.info(
            this,
            "#delete('%[text]s'): deleted item in '%s', %s, in %[ms]s",
            attributes, this.self,
            new PrintableConsumedCapacity(
                result.getConsumedCapacity()
            ).print(),
            System.currentTimeMillis() - start
        );
    } catch (final AmazonClientException ex) {
        throw new IOException(
            String.format(
                "failed to delete at \"%s\" by keys %s",
                this.self, attributes
            ),
            ex
        );
    } finally {
        aws.shutdown();
    }
}

public DeleteItemResult deleteItem(final String tableName, final Map<String, AttributeValue> key) {
    return dynamoDB.deleteItem(tableName, key);
}

public DeleteItemResult deleteItem(final String tableName, final Map<String, AttributeValue> key, final String returnValues) {
    return dynamoDB.deleteItem(tableName, key, returnValues);
}

public DeleteItemResult deleteItem(final DeleteItemRequest deleteItemRequest) {
    return dynamoDB.deleteItem(deleteItemRequest);
}

@Override
public DeleteItemResult deleteItem(DeleteItemRequest deleteItemRequest) {
    this.deleteItemRequest = deleteItemRequest;
    return new DeleteItemResult().withAttributes(getAttributes());
}

@Override
protected DeleteItemResult call() throws BackendException {
    return delegate.deleteItem(request);
}

/**
 * AwsTable can delete an item.
 * @throws Exception If some problem inside
 */
@Test
public void deletesItemFromDynamo() throws Exception {
    final Credentials credentials = Mockito.mock(Credentials.class);
    final AmazonDynamoDB aws = Mockito.mock(AmazonDynamoDB.class);
    Mockito.doReturn(aws).when(credentials).aws();
    Mockito.doReturn(
        new DeleteItemResult().withConsumedCapacity(
            new ConsumedCapacity().withCapacityUnits(1.0d)
        )
    ).when(aws).deleteItem(Mockito.any(DeleteItemRequest.class));
    Mockito.doReturn(
        new DescribeTableResult().withTable(
            new TableDescription().withKeySchema(
                new KeySchemaElement().withAttributeName(AwsTableTest.KEY)
            )
        )
    ).when(aws).describeTable(Mockito.any(DescribeTableRequest.class));
    final String attr = "attribute-2";
    final AttributeValue value = new AttributeValue("value-2");
    final String name = "table-name-2";
    final Table table = new AwsTable(
        credentials, Mockito.mock(Region.class), name
    );
    table.delete(new Attributes().with(attr, value));
    Mockito.verify(aws).deleteItem(
        DeleteItemRequest.class.cast(
            MockitoHamcrest.argThat(
                Matchers.allOf(
                    Matchers.hasProperty(
                        AwsTableTest.TABLE_NAME,
                        Matchers.equalTo(name)
                    ),
                    Matchers.hasProperty(
                        AwsTableTest.KEY,
                        Matchers.hasEntry(
                            Matchers.equalTo(attr),
                            Matchers.equalTo(value)
                        )
                    )
                )
            )
        )
    );
}

public DeletePointResult(DeleteItemResult deleteItemResult) {
    this.deleteItemResult = deleteItemResult;
}

public DeleteItemResult getDeleteItemResult() {
    return deleteItemResult;
}

/**
 * Deletes a single item in a table by primary key
 * 
 * You can perform a conditional delete operation that deletes the item if
 * it exists, or if it has an expected attribute value.
 * 
 * @param tableName
 *              - The name of the table
 * @param primaryKey
 *              - The primary key of the item
 * @return
 */
DeleteItemResult deleteItem(String tableName,
        HashMap<String, AttributeValue> primaryKey);