Java QueryResult类代码示例

import com.amazonaws.services.dynamodbv2.model.QueryResult; //导入依赖的package包/类
private QueryOutcome query(Object hk, QuerySpec querySpec, PageIterator pageIterator) {
    if ( null == _convertMarker ) {
        throw new IllegalStateException("Index must first be initialized with ConvertMarker");
    }
    if ( pageIterator.getPageSize() <= 0 ) {
        return new QueryOutcome(new QueryResult());
    }
    ItemCollection<QueryOutcome> itemCollection =
        maybeBackoff(true, () ->
                     _query.query(withMarker(querySpec.withHashKey(_hkName, hk), pageIterator, hk)));

    if ( null != itemCollection ) {
        Iterator<Page<Item, QueryOutcome>> iterator = itemCollection.pages().iterator();
        if ( iterator.hasNext() ) {
            QueryOutcome outcome = maybeBackoff(true, () -> iterator.next().getLowLevelResult());
            QueryResult result = outcome.getQueryResult();
            if ( null != pageIterator.getMarker() && null != result.getItems() && result.getItems().size() > 0 ) {
                pageIterator.setPrevMarker(toMarker(result.getItems().get(0), true));
            } else {
                pageIterator.setPrevMarker(null);
            }
            Map<String,AttributeValue> lastKey = result.getLastEvaluatedKey();
            if ( null != lastKey && ! lastKey.isEmpty() ) {
                pageIterator.setMarker(toMarker(lastKey, true));
            } else {
                pageIterator.setMarker(null);
            }
            return outcome;
        }
    }
    pageIterator.setPrevMarker(null);
    pageIterator.setMarker(null);
    return new QueryOutcome(new QueryResult());
}
 

import com.amazonaws.services.dynamodbv2.model.QueryResult; //导入依赖的package包/类
@Test
public void testDeleteSecretMaliciousResults() {
    QueryRequest request = constructQueryRequest(SECRET_NAME);

    // Result contains entries that do no match the filter in the request (i.e. items for secret2). So it should be
    // considered malicious.
    QueryResult maliciousResult = constructQueryResult(true);
    when(mockDynamoDBClient.query(request)).thenReturn(maliciousResult);

    // Call the delete secret method.
    boolean consideredMalicious = false;
    try {
        dynamoDB.delete(new SecretIdentifier(SECRET_NAME));
    } catch (PotentiallyMaliciousDataException e) {
        consideredMalicious = true;
    }
    assertTrue(consideredMalicious);

    // Verify nothing was actually deleted because the malicious check failed.
    verify(mockDynamoDBClient, times(1)).query(request);
    verify(mockDynamoDBClient, never()).deleteItem(tableName, constructKey(SECRET_NAME, 1));
    verify(mockDynamoDBClient, never()).deleteItem(tableName, constructKey(SECRET_NAME, 2));
    verify(mockDynamoDBClient, never()).deleteItem(tableName, constructKey(SECRET2_NAME, 1));
}
 

import com.amazonaws.services.dynamodbv2.model.QueryResult; //导入依赖的package包/类
/**
 * 
 * @param targetClass <code>Map</code> or entity class with getter/setter method.
 * @param queryRequest
 * @return
 */
public <T> List<T> find(final Class<T> targetClass, final QueryRequest queryRequest) {
    final QueryResult queryResult = dynamoDB.query(queryRequest);
    final List<T> res = toList(targetClass, queryResult);

    if (N.notNullOrEmpty(queryResult.getLastEvaluatedKey()) && N.isNullOrEmpty(queryRequest.getExclusiveStartKey())) {
        final QueryRequest newQueryRequest = queryRequest.clone();
        QueryResult newQueryResult = queryResult;

        while (N.notNullOrEmpty(newQueryResult.getLastEvaluatedKey())) {
            newQueryRequest.setExclusiveStartKey(newQueryResult.getLastEvaluatedKey());
            newQueryResult = dynamoDB.query(newQueryRequest);
            res.addAll(toList(targetClass, newQueryResult));
        }
    }

    return res;
}
 

import com.amazonaws.services.dynamodbv2.model.QueryResult; //导入依赖的package包/类
/**
 * 
 * @param targetClass
 * @param queryRequest
 * @return
 * @see #find(Class, QueryRequest)
 */
public DataSet query(final Class<?> targetClass, final QueryRequest queryRequest) {
    if (targetClass == null || Map.class.isAssignableFrom(targetClass)) {
        final QueryResult queryResult = dynamoDB.query(queryRequest);
        final List<Map<String, AttributeValue>> items = queryResult.getItems();

        if (N.notNullOrEmpty(queryResult.getLastEvaluatedKey()) && N.isNullOrEmpty(queryRequest.getExclusiveStartKey())) {
            final QueryRequest newQueryRequest = queryRequest.clone();
            QueryResult newQueryResult = queryResult;

            while (N.notNullOrEmpty(newQueryResult.getLastEvaluatedKey())) {
                newQueryRequest.setExclusiveStartKey(newQueryResult.getLastEvaluatedKey());
                newQueryResult = dynamoDB.query(newQueryRequest);
                items.addAll(newQueryResult.getItems());
            }
        }

        return extractData(items, 0, items.size());
    } else {
        return N.newDataSet(find(targetClass, queryRequest));
    }
}
 

import com.amazonaws.services.dynamodbv2.model.QueryResult; //导入依赖的package包/类
public RetryResult<QueryResult> queryTable(
    String tableName, DynamoDBQueryFilter dynamoDBQueryFilter, Map<String, AttributeValue>
    exclusiveStartKey, long limit, Reporter reporter) {
  final QueryRequest queryRequest = new QueryRequest()
      .withTableName(tableName)
      .withExclusiveStartKey(exclusiveStartKey)
      .withKeyConditions(dynamoDBQueryFilter.getKeyConditions())
      .withLimit(Ints.checkedCast(limit))
      .withReturnConsumedCapacity(ReturnConsumedCapacity.TOTAL);

  RetryResult<QueryResult> retryResult = getRetryDriver().runWithRetry(
      new Callable<QueryResult>() {
        @Override
        public QueryResult call() {
          log.debug("Executing DynamoDB query: " + queryRequest);
          return dynamoDB.query(queryRequest);
        }
      }, reporter, PrintCounter.DynamoDBReadThrottle);
  return retryResult;
}
 

import com.amazonaws.services.dynamodbv2.model.QueryResult; //导入依赖的package包/类
public Account accountGetAccountByToken(String token) {
	
	Condition hashKeyCondition = new Condition();
	hashKeyCondition.withComparisonOperator(ComparisonOperator.EQ).withAttributeValueList(new AttributeValue().withS(token));

	Map<String, Condition> keyConditions = new HashMap<String, Condition>();
	keyConditions.put("accountToken", hashKeyCondition);

	QueryRequest queryRequest = new QueryRequest();
	queryRequest.withTableName("accountsv2");
	queryRequest.withIndexName("accountToken-index");
	queryRequest.withKeyConditions(keyConditions);

	QueryResult result = dynamoDB.query(queryRequest);

	for(Map<String, AttributeValue> item : result.getItems()) {
		Account mappedItem = mapper.marshallIntoObject(Account.class, item);
		// Only want the First one
		return mappedItem;
	}
	
	return null;
}
 

import com.amazonaws.services.dynamodbv2.model.QueryResult; //导入依赖的package包/类
@Override
public void execute() {
    QueryResult result = ddbClient.query(new QueryRequest()
            .withTableName(determineTableName())
            .withAttributesToGet(determineAttributeNames())
            .withConsistentRead(determineConsistentRead())
            .withExclusiveStartKey(determineStartKey())
            .withKeyConditions(determineKeyConditions())
            .withExclusiveStartKey(determineStartKey())
            .withLimit(determineLimit())
            .withScanIndexForward(determineScanIndexForward()));
    
    Map tmp = new HashMap<>();
    tmp.put(DdbConstants.ITEMS, result.getItems());
    tmp.put(DdbConstants.LAST_EVALUATED_KEY, result.getLastEvaluatedKey());
    tmp.put(DdbConstants.CONSUMED_CAPACITY, result.getConsumedCapacity());
    tmp.put(DdbConstants.COUNT, result.getCount());
    addToResults(tmp);
}
 

import com.amazonaws.services.dynamodbv2.model.QueryResult; //导入依赖的package包/类
public QueryResult query(final QueryRequest request, final int permitsToConsume) throws BackendException {
    setUserAgent(request);
    QueryResult result;
    timedReadThrottle(QUERY, request.getTableName(), permitsToConsume);
    final Timer.Context apiTimerContext = getTimerContext(QUERY, request.getTableName());
    try {
        result = client.query(request);
    } catch (Exception e) {
        throw processDynamoDbApiException(e, QUERY, request.getTableName());
    } finally {
        apiTimerContext.stop();
    }
    meterConsumedCapacity(QUERY, result.getConsumedCapacity());
    measureItemCount(QUERY, request.getTableName(), result.getCount());
    return result;
}
 

import com.amazonaws.services.dynamodbv2.model.QueryResult; //导入依赖的package包/类
@Override
public Map<StaticBuffer, EntryList> getSlice(final List<StaticBuffer> keys, final SliceQuery query, final StoreTransaction txh) throws BackendException {
    log.debug("Entering getSliceMultiSliceQuery table:{} keys:{} query:{} txh:{}",
              getTableName(),
              encodeForLog(keys),
              encodeForLog(query),
              txh);

    final Map<StaticBuffer, EntryList> resultMap = Maps.newHashMapWithExpectedSize(keys.size());

    final List<QueryWorker> queryWorkers = Lists.newLinkedList();
    for (StaticBuffer hashKey : keys) {
        final QueryWorker queryWorker = buildQueryWorker(hashKey, query);
        queryWorkers.add(queryWorker);

        resultMap.put(hashKey, EntryList.EMPTY_LIST);
    }

    final List<QueryResultWrapper> results = client.getDelegate().parallelQuery(queryWorkers);
    for (QueryResultWrapper resultWrapper : results) {
        final StaticBuffer titanKey = resultWrapper.getTitanKey();

        final QueryResult dynamoDBResult = resultWrapper.getDynamoDBResult();
        final EntryList entryList = createEntryListFromItems(dynamoDBResult.getItems(), query);
        resultMap.put(titanKey, entryList);
    }

    log.debug("Exiting getSliceMultiSliceQuery table:{} keys:{} query:{} txh:{} returning:{}",
              getTableName(),
              encodeForLog(keys),
              encodeForLog(query),
              txh,
              resultMap.size());
    return resultMap;
}
 

import com.amazonaws.services.dynamodbv2.model.QueryResult; //导入依赖的package包/类
@Override
public QueryResultWrapper next() throws BackendException {
    final Query backoff = new ExponentialBackoff.Query(request, delegate, permitsToConsume);
    final QueryResult result = backoff.runWithBackoff();
    final ConsumedCapacity consumedCapacity = result.getConsumedCapacity();
    if (null != consumedCapacity) {
        permitsToConsume = Math.max((int) (consumedCapacity.getCapacityUnits() - 1.0), 1);
        totalCapacityUnits += consumedCapacity.getCapacityUnits();
    }

    if (result.getLastEvaluatedKey() != null && !result.getLastEvaluatedKey().isEmpty()) {
        request.setExclusiveStartKey(result.getLastEvaluatedKey());
    } else {
        markComplete();
    }
    // a update returned count
    returnedCount += result.getCount();

    // b update scanned count
    scannedCount += result.getScannedCount();
    // c add scanned finalItemList
    finalItemList.addAll(result.getItems());
    return new QueryResultWrapper(titanKey, result);
}
 

import com.amazonaws.services.dynamodbv2.model.QueryResult; //导入依赖的package包/类
@Override
public boolean hasNext() {
    if (closed) {
        return false;
    }
    if (currentIterator.hasNext()) {
        return true;
    }
    // Loop until the query finds a new result.
    // This is necessary because even if the query worker has a next page it might have no results.
    while (queryWorker.hasNext() && !currentIterator.hasNext()) {
        try {
            final QueryResultWrapper resultWrapper = queryWorker.next();
            final QueryResult queryResult = resultWrapper.getDynamoDBResult();

            currentIterator = buildRecordIteratorFromQueryResult(queryResult);
        } catch (BackendException e) {
            throw new RuntimeException(e);
        }
    }
    return currentIterator.hasNext();
}
 

import com.amazonaws.services.dynamodbv2.model.QueryResult; //导入依赖的package包/类
public static List<Map<String, AttributeValue>> queryUntilDone(
		AmazonDynamoDB dynamoClient, QueryRequest qr, int backoffMillis)
		throws Exception {
	List<Map<String, AttributeValue>> output = new ArrayList<>();

	Map<String, AttributeValue> lastKeyEvaluated = null;
	do {
		int queryAttempts = 0;
		QueryResult result = null;

		do {
			try {
				result = dynamoClient.query(qr).withLastEvaluatedKey(
						lastKeyEvaluated);

				output.addAll(result.getItems());
			} catch (ProvisionedThroughputExceededException e) {
				LOG.warn(String
						.format("Provisioned Throughput Exceeded - Retry Attempt %s",
								queryAttempts));

				Thread.sleep(2 ^ queryAttempts * backoffMillis);

				queryAttempts++;
			}
		} while (queryAttempts < 10 && result == null);

		if (result == null) {
			throw new Exception(String.format(
					"Unable to execute Query after %s attempts",
					queryAttempts));
		}

		lastKeyEvaluated = result.getLastEvaluatedKey();
	} while (lastKeyEvaluated != null);

	return output;
}
 

import com.amazonaws.services.dynamodbv2.model.QueryResult; //导入依赖的package包/类
private static void findRepliesForAThread(String forumName, String threadSubject) {

        String replyId = forumName + "#" + threadSubject;
        
        Condition hashKeyCondition = new Condition()
            .withComparisonOperator(ComparisonOperator.EQ)
            .withAttributeValueList(new AttributeValue().withS(replyId));
        
        Map<String, Condition> keyConditions = new HashMap<String, Condition>();
        keyConditions.put("Id", hashKeyCondition);
        
        QueryRequest queryRequest = new QueryRequest()
            .withTableName(tableName)
            .withKeyConditions(keyConditions);

        QueryResult result = client.query(queryRequest);
        for (Map<String, AttributeValue> item : result.getItems()) {
            printItem(item);
        }
    }
 

import com.amazonaws.services.dynamodbv2.model.QueryResult; //导入依赖的package包/类
private static void findRepliesForAThreadSpecifyOptionalLimit(String forumName, String threadSubject) {
    
    Map<String, AttributeValue> lastEvaluatedKey = null;
    do {
        QueryRequest queryRequest = new QueryRequest()
                .withTableName(tableName)
                .withKeyConditions(makeReplyKeyConditions(forumName, threadSubject))
                .withLimit(1)
                .withExclusiveStartKey(lastEvaluatedKey);

        QueryResult result = client.query(queryRequest);
        for (Map<String, AttributeValue> item : result.getItems()) {
            printItem(item);
        }
        lastEvaluatedKey = result.getLastEvaluatedKey();
    } while (lastEvaluatedKey != null);        
}
 

import com.amazonaws.services.dynamodbv2.model.QueryResult; //导入依赖的package包/类
private static void findRepliesInLast15DaysWithConfig(String forumName, String threadSubject) {

        long twoWeeksAgoMilli = (new Date()).getTime() - (15L*24L*60L*60L*1000L);
        Date twoWeeksAgo = new Date();
        twoWeeksAgo.setTime(twoWeeksAgoMilli);
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
        String twoWeeksAgoStr = df.format(twoWeeksAgo);

        Condition rangeKeyCondition = new Condition()
            .withComparisonOperator(ComparisonOperator.GT.toString())
            .withAttributeValueList(new AttributeValue().withS(twoWeeksAgoStr));
        
        Map<String, Condition> keyConditions = makeReplyKeyConditions(forumName, threadSubject);
        keyConditions.put("ReplyDateTime", rangeKeyCondition);
        
        QueryRequest queryRequest = new QueryRequest().withTableName(tableName)
            .withKeyConditions(keyConditions)
            .withProjectionExpression("Message, ReplyDateTime, PostedBy");

        QueryResult result = client.query(queryRequest);
        for (Map<String, AttributeValue> item : result.getItems()) {
            printItem(item);
        }

    }