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

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

private static void findRepliesForAThread(String forumName, String threadSubject) {

        String replyId = forumName + "#" + threadSubject;

        Condition partitionKeyCondition = new Condition().withComparisonOperator(ComparisonOperator.EQ)
            .withAttributeValueList(new AttributeValue().withS(replyId));

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

        QueryRequest queryRequest = new QueryRequest().withTableName(tableName).withKeyConditions(keyConditions);

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

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 sortKeyCondition = new Condition().withComparisonOperator(ComparisonOperator.GT.toString())
            .withAttributeValueList(new AttributeValue().withS(twoWeeksAgoStr));

        Map<String, Condition> keyConditions = makeReplyKeyConditions(forumName, threadSubject);
        keyConditions.put("ReplyDateTime", sortKeyCondition);

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

    }
 

private static void findRepliesPostedWithinTimePeriod(String forumName, String threadSubject) {

        long startDateMilli = (new Date()).getTime() - (15L * 24L * 60L * 60L * 1000L);
        long endDateMilli = (new Date()).getTime() - (5L * 24L * 60L * 60L * 1000L);
        java.text.SimpleDateFormat df = new java.text.SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
        String startDate = df.format(startDateMilli);
        String endDate = df.format(endDateMilli);

        Condition sortKeyCondition = new Condition().withComparisonOperator(ComparisonOperator.BETWEEN.toString())
            .withAttributeValueList(new AttributeValue().withS(startDate), new AttributeValue().withS(endDate));

        Map<String, Condition> keyConditions = makeReplyKeyConditions(forumName, threadSubject);
        keyConditions.put("ReplyDateTime", sortKeyCondition);

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

public void run() {
	QueryRequest queryRequest = DynamoDBUtil.copyQueryRequest(geoQueryRequest.getQueryRequest());
	long hashKey = S2Manager.generateHashKey(range.getRangeMin(), config.getHashKeyLength());

	List<QueryResult> queryResults = dynamoDBManager.queryGeohash(queryRequest, hashKey, range);

	for (QueryResult queryResult : queryResults) {
		if (isInterrupted()) {
			return;
		}

		// getQueryResults() returns a synchronized list.
		geoQueryResult.getQueryResults().add(queryResult);

		List<Map<String, AttributeValue>> filteredQueryResult = filter(queryResult.getItems(), geoQueryRequest);

		// getItem() returns a synchronized list.
		geoQueryResult.getItem().addAll(filteredQueryResult);
	}
}
 

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

@Override
public long getMaxVersion(final String materialName) {
    final List<Map<String, AttributeValue>> items = ddb.query(
            new QueryRequest()
            .withTableName(tableName)
            .withConsistentRead(Boolean.TRUE)
            .withKeyConditions(
                    Collections.singletonMap(
                            DEFAULT_HASH_KEY,
                            new Condition().withComparisonOperator(
                                    ComparisonOperator.EQ).withAttributeValueList(
                                            new AttributeValue().withS(materialName))))
                                            .withLimit(1).withScanIndexForward(false)
                                            .withAttributesToGet(DEFAULT_RANGE_KEY)).getItems();
    if (items.isEmpty()) {
        return -1L;
    } else {
        return Long.parseLong(items.get(0).get(DEFAULT_RANGE_KEY).getN());
    }
}
 

private static <T> QueryRequest testCreateQueryRequestFromExpression(
        Class<T> clazz, DynamoDBQueryExpression<T> queryExpression,
        String expectedErrorMessage) {
    try {
        QueryRequest request = (QueryRequest) testedMethod.invoke(mapper, clazz, queryExpression, DynamoDBMapperConfig.DEFAULT);
        if (expectedErrorMessage != null) {
            fail("Exception containing messsage ("
                    + expectedErrorMessage + ") is expected.");
        }
        return request;
    } catch (InvocationTargetException ite) {
        if (expectedErrorMessage != null) {
            assertTrue("Exception message [" + ite.getCause().getMessage() + "] does not contain " +
                            "the expected message [" + expectedErrorMessage + "].",
                    ite.getCause().getMessage().contains(expectedErrorMessage));
        } else {
            ite.getCause().printStackTrace();
            fail("Internal error when calling createQueryRequestFromExpressio method");
        }
    } catch (Exception e) {
        fail(e.getMessage());
    }
    return null;
}
 

private List<QueryRequest> addQueryRanges(
    final String tableName,
    final SinglePartitionQueryRanges r,
    short[] adapterIds,
    final InternalAdapterStore adapterStore) {
  final List<QueryRequest> retVal = new ArrayList<>();
  final byte[] partitionKey = DynamoDBUtils.getDynamoDBSafePartitionKey(r.getPartitionKey());
  if (((adapterIds == null) || (adapterIds.length == 0)) && (adapterStore != null)) {
    adapterIds = adapterStore.getAdapterIds();
  }

  for (final Short adapterId : adapterIds) {
    final Collection<ByteArrayRange> sortKeyRanges = r.getSortKeyRanges();
    if ((sortKeyRanges != null) && !sortKeyRanges.isEmpty()) {
      sortKeyRanges.forEach(
          (sortKeyRange -> retVal.add(
              getQuery(tableName, partitionKey, sortKeyRange, adapterId))));
    } else {
      retVal.add(getQuery(tableName, partitionKey, null, adapterId));
    }
  }
  return retVal;
}
 

protected Query<T> buildFinderQuery(DynamoDBOperations dynamoDBOperations) {
	if (isApplicableForQuery()) {
		if (isApplicableForGlobalSecondaryIndex()) {
			String tableName = dynamoDBOperations.getOverriddenTableName(entityInformation.getDynamoDBTableName());
			QueryRequest queryRequest = buildQueryRequest(tableName, getGlobalSecondaryIndexName(),
					getHashKeyAttributeName(), getRangeKeyAttributeName(), this.getRangeKeyPropertyName(),
					getHashKeyConditions(), getRangeKeyConditions());
			return new MultipleEntityQueryRequestQuery<T>(dynamoDBOperations,entityInformation.getJavaType(), queryRequest);
		} else {
			DynamoDBQueryExpression<T> queryExpression = buildQueryExpression();
			return new MultipleEntityQueryExpressionQuery<T>(dynamoDBOperations, entityInformation.getJavaType(), queryExpression);
		}
	} else {
		return new MultipleEntityScanExpressionQuery<T>(dynamoDBOperations, clazz, buildScanExpression());
	}
}
 

protected Query<Long> buildFinderCountQuery(DynamoDBOperations dynamoDBOperations,boolean pageQuery) {
	if (isApplicableForQuery()) {
		if (isApplicableForGlobalSecondaryIndex()) {
			String tableName = dynamoDBOperations.getOverriddenTableName(entityInformation.getDynamoDBTableName());
			QueryRequest queryRequest = buildQueryRequest(tableName, getGlobalSecondaryIndexName(),
					getHashKeyAttributeName(), getRangeKeyAttributeName(), this.getRangeKeyPropertyName(),
					getHashKeyConditions(), getRangeKeyConditions());
			return new QueryRequestCountQuery<T>(dynamoDBOperations,entityInformation.getJavaType(), queryRequest);
	
		} else {
			DynamoDBQueryExpression<T> queryExpression = buildQueryExpression();
			return new QueryExpressionCountQuery<T>(dynamoDBOperations, entityInformation.getJavaType(), queryExpression);
	
		}
	} else {
		return new ScanExpressionCountQuery<T>(dynamoDBOperations, clazz, buildScanExpression(),pageQuery);
	}
}
 

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

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

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

    }
 

private static void findRepliesUsingAFilterExpression(String forumName, String threadSubject) {
         
   Map<String, Condition> keyConditions = makeReplyKeyConditions(forumName, threadSubject);
   
   Map<String, AttributeValue> expressionAttributeValues = new HashMap<String, AttributeValue>();
   expressionAttributeValues.put(":val", new AttributeValue().withS("User B")); 
   
   QueryRequest queryRequest = new QueryRequest()
       .withTableName(tableName)
       .withKeyConditions(keyConditions)
       .withFilterExpression("PostedBy = :val")
       .withExpressionAttributeValues(expressionAttributeValues)
       .withProjectionExpression("Message, ReplyDateTime, PostedBy");

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

@Override
public final Response query(final Request request) {

    final Map<String, AttributeValue> expressionAttributeValues = new HashMap<>();
    expressionAttributeValues.put(":" + request.getPartitionKey(),
            new AttributeValue(request.getPartitionKeyValue()));

    final String keyConditionExpression = request.getPartitionKey() + "=:" + request.getPartitionKey();

    QueryRequest queryRequest = new QueryRequest()
            .withTableName(request.getTableName())
            .withKeyConditionExpression(keyConditionExpression)
            .withExpressionAttributeValues(expressionAttributeValues);

    StringBuilder filterExpressionBuilder;
    if (request.getFilterData() != null) {
        filterExpressionBuilder = new StringBuilder();
        processFilterData(request, filterExpressionBuilder, expressionAttributeValues);
        //Add to QueryRequest.
        queryRequest.withFilterExpression(filterExpressionBuilder.toString());
    }

    final QueryResult queryResult = dynamoDBClient.query(queryRequest);

    final StringBuilder response = new StringBuilder();
    response.append("PK of items read with query (V2): ");
    for (Map<String, AttributeValue> item : queryResult.getItems()) {
        response.append(prepareKeyStr(item, request));
    }


    return new Response(response.toString(), null);
}
 

private static QueryRequest constructQueryRequest(String secretName) {
    Map<String, String> expressionAttributeNames = new HashMap<>();
    expressionAttributeNames.put("#1", KEY_ATTRIBUTE_NAME.toString());
    Map<String, AttributeValue> expressionAttributeValues = new HashMap<>();
    expressionAttributeValues.put(":a", new AttributeValue().withS(secretName));

    QueryRequest request = new QueryRequest()
            .withTableName(tableName)
            .withConsistentRead(true)
            .withKeyConditionExpression("#1 = :a")
            .withExpressionAttributeNames(expressionAttributeNames)
            .withExpressionAttributeValues(expressionAttributeValues);
    return request;
}
 

@Test
public void testDeleteSecret() {
    QueryRequest request = constructQueryRequest(SECRET_NAME);
    QueryResult result = constructQueryResult(false);
    when(mockDynamoDBClient.query(request)).thenReturn(result);

    // Call the delete secret method.
    dynamoDB.delete(new SecretIdentifier(SECRET_NAME));

    // Verify only the entries matching the correct secret were deleted.
    verify(mockDynamoDBClient, times(1)).query(request);
    verify(mockDynamoDBClient, times(1)).deleteItem(tableName, constructKey(SECRET_NAME, 1));
    verify(mockDynamoDBClient, times(1)).deleteItem(tableName, constructKey(SECRET_NAME, 2));
    verify(mockDynamoDBClient, never()).deleteItem(tableName, constructKey(SECRET2_NAME, 1));
}
 

@Test
public void testDeleteSecretNotInTable() {
    QueryRequest request = constructQueryRequest(SECRET_NAME);
    QueryResult result = new QueryResult().withCount(0).withItems(new ArrayList<>());
    when(mockDynamoDBClient.query(request)).thenReturn(result);

    // Try deleting the secret. Method should complete without throwing exception but deleteItem will not be
    // called for any secrets.
    dynamoDB.delete(new SecretIdentifier(SECRET_NAME));
    verify(mockDynamoDBClient, times(1)).query(request);
    verify(mockDynamoDBClient, never()).deleteItem(tableName, constructKey(SECRET_NAME, 1));
}
 

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

@Override
public QueryResult query(QueryRequest request) throws AmazonServiceException,
        AmazonClientException {
    Collection<String> attributesToGet = addSpecialAttributes(request.getAttributesToGet());
    request.setAttributesToGet(attributesToGet);
    QueryResult result = txManager.getClient().query(request);
    List<Map<String, AttributeValue>> items = handleItems(result.getItems(), request.getTableName(), request.getAttributesToGet());
    result.setItems(items);
    return result;
}
 

public QueryWorker buildQueryWorker(final StaticBuffer hashKey, final SliceQuery query) {
    final QueryRequest request = createQueryRequest(hashKey, query);
    // Only enforce a limit when Titan tells us to
    if (query.hasLimit()) {
        final int limit = query.getLimit();
        request.setLimit(limit);
        return new QueryWithLimitWorker(client.getDelegate(), request, hashKey, limit);
    }

    return new QueryWorker(client.getDelegate(), request, hashKey);
}
 

private QueryRequest createQueryRequest(final StaticBuffer hashKey, final SliceQuery rangeQuery) {
    final Expression keyConditionExpression = new ConditionExpressionBuilder().hashKey(hashKey)
            .rangeKey(rangeQuery.getSliceStart(), rangeQuery.getSliceEnd())
            .build();

    return super.createQueryRequest()
           .withKeyConditionExpression(keyConditionExpression.getConditionExpression())
           .withExpressionAttributeValues(keyConditionExpression.getAttributeValues());
}
 

QueryWorker(final DynamoDbDelegate delegate, final QueryRequest request, final StaticBuffer titanKey) {
    super(delegate, DynamoDbDelegate.QUERY, request.getTableName());
    this.request = request;
    this.titanKey = titanKey;
    this.returnedCount = 0;
    this.scannedCount = 0;
    this.finalItemList = new ArrayList<>();
    this.permitsToConsume = 1;
    this.totalCapacityUnits = 0.0;
}
 

@Test
public void testHashOnlyQueryOnHashRangeTable() {
    // Primary hash only query on a Hash+Range table
    QueryRequest queryRequest = testCreateQueryRequestFromExpression(
            LSIRangeKeyTestClass.class,
            new DynamoDBQueryExpression<LSIRangeKeyTestClass>()
                    .withHashKeyValues(new LSIRangeKeyTestClass("foo", null)));
    assertTrue(queryRequest.getKeyConditions().size() == 1);
    assertTrue(queryRequest.getKeyConditions().containsKey("primaryHashKey"));
    assertNull(queryRequest.getIndexName());

    // Hash+Range query on a LSI
    queryRequest = testCreateQueryRequestFromExpression(
            LSIRangeKeyTestClass.class,
            new DynamoDBQueryExpression<LSIRangeKeyTestClass>()
                    .withHashKeyValues(new LSIRangeKeyTestClass("foo", null))
                    .withRangeKeyCondition("lsiRangeKey", RANGE_KEY_CONDITION)
                    .withIndexName("LSI"));
    assertTrue(queryRequest.getKeyConditions().size() == 2);
    assertTrue(queryRequest.getKeyConditions().containsKey("primaryHashKey"));
    assertTrue(queryRequest.getKeyConditions().containsKey("lsiRangeKey"));
    assertEquals("LSI", queryRequest.getIndexName());

    // Hash-only query on a LSI
    queryRequest = testCreateQueryRequestFromExpression(
            LSIRangeKeyTestClass.class,
            new DynamoDBQueryExpression<LSIRangeKeyTestClass>()
                    .withHashKeyValues(new LSIRangeKeyTestClass("foo", null))
                    .withIndexName("LSI"));
    assertTrue(queryRequest.getKeyConditions().size() == 1);
    assertTrue(queryRequest.getKeyConditions().containsKey("primaryHashKey"));
    assertEquals("LSI", queryRequest.getIndexName());
}
 

@Override
  public List<DColumn> getColumns(String storeName, String rowKey, String startColumn, String endColumn, int count) {
  	Timer t = new Timer();
  	String key = storeName + "_" + rowKey;
  	HashMap<String,Condition> keyConditions = new HashMap<String,Condition>();
  	keyConditions.put("key", new Condition()
	.withComparisonOperator(ComparisonOperator.EQ)
	.withAttributeValueList(new AttributeValue().withS(key)));
  	if(startColumn != null && endColumn != null) {
      	keyConditions.put("column", new Condition()
  			.withComparisonOperator(ComparisonOperator.BETWEEN)
  			.withAttributeValueList(new AttributeValue().withS(startColumn), new AttributeValue(endColumn)));
  	} else if(startColumn != null) {
      	keyConditions.put("column", new Condition()
  			.withComparisonOperator(ComparisonOperator.GE)
  			.withAttributeValueList(new AttributeValue().withS(startColumn)));
  	} else if(endColumn != null) {
      	keyConditions.put("column", new Condition()
  			.withComparisonOperator(ComparisonOperator.LT)
  			.withAttributeValueList(new AttributeValue().withS(endColumn)));
  	}

QueryRequest request = new QueryRequest()
	.withTableName(getTenant().getName())
	.withLimit(Math.min(100,  count))
	.withKeyConditions(keyConditions);
QueryResult result = m_client.query(request);
List<DColumn> list = fromItems(result.getItems());
      m_logger.debug("get columns range for {} in {}", getTenant().getName(), t);
  	return list;
  }
 

@Override
public boolean delete(final MetadataQuery metadata) {
  // the nature of metadata deleter is that primary ID is always
  // well-defined and it is deleting a single entry at a time
  final String tableName = operations.getMetadataTableName(metadataType);
  final QueryRequest queryRequest = new QueryRequest(tableName);

  if (metadata.hasSecondaryId()) {
    queryRequest.withFilterExpression(
        DynamoDBOperations.METADATA_SECONDARY_ID_KEY
            + " = :secVal").addExpressionAttributeValuesEntry(
                ":secVal",
                new AttributeValue().withB(ByteBuffer.wrap(metadata.getSecondaryId())));
  }
  queryRequest.withKeyConditionExpression(
      DynamoDBOperations.METADATA_PRIMARY_ID_KEY
          + " = :priVal").addExpressionAttributeValuesEntry(
              ":priVal",
              new AttributeValue().withB(ByteBuffer.wrap(metadata.getPrimaryId())));

  final QueryResult queryResult = operations.getClient().query(queryRequest);
  for (final Map<String, AttributeValue> entry : queryResult.getItems()) {
    final Map<String, AttributeValue> key = new HashMap<>();
    key.put(
        DynamoDBOperations.METADATA_PRIMARY_ID_KEY,
        entry.get(DynamoDBOperations.METADATA_PRIMARY_ID_KEY));
    key.put(
        DynamoDBOperations.METADATA_TIMESTAMP_KEY,
        entry.get(DynamoDBOperations.METADATA_TIMESTAMP_KEY));
    operations.getClient().deleteItem(tableName, key);
  }

  return true;
}
 

protected void initScanner() {
  final String tableName = operations.getQualifiedTableName(readerParams.getIndex().getName());

  // if ((readerParams.getLimit() != null) && (readerParams.getLimit() >
  // 0)) {
  // TODO: we should do something here
  // }

  final List<QueryRequest> requests = new ArrayList<>();

  final Collection<SinglePartitionQueryRanges> ranges =
      readerParams.getQueryRanges().getPartitionQueryRanges();

  if ((ranges != null) && !ranges.isEmpty()) {
    ranges.forEach(
        (queryRequest -> requests.addAll(
            addQueryRanges(
                tableName,
                queryRequest,
                readerParams.getAdapterIds(),
                readerParams.getInternalAdapterStore()))));
  }
  // else if ((readerParams.getAdapterIds() != null) &&
  // !readerParams.getAdapterIds().isEmpty()) {
  // //TODO this isn't going to work because there aren't partition keys
  // being passed along
  // requests.addAll(
  // getAdapterOnlyQueryRequests(
  // tableName,
  // readerParams.getAdapterIds()));
  // }

  startRead(
      requests,
      tableName,
      DataStoreUtils.isMergingIteratorRequired(readerParams, visibilityEnabled),
      readerParams.getMaxResolutionSubsamplingPerDimension() == null);
}
 

public static QueryRequest copyQueryRequest(QueryRequest queryRequest) {
	QueryRequest copiedQueryRequest = new QueryRequest().withAttributesToGet(queryRequest.getAttributesToGet())
			.withConsistentRead(queryRequest.getConsistentRead())
			.withExclusiveStartKey(queryRequest.getExclusiveStartKey()).withIndexName(queryRequest.getIndexName())
			.withKeyConditions(queryRequest.getKeyConditions()).withLimit(queryRequest.getLimit())
			.withReturnConsumedCapacity(queryRequest.getReturnConsumedCapacity())
			.withScanIndexForward(queryRequest.getScanIndexForward()).withSelect(queryRequest.getSelect())
			.withTableName(queryRequest.getTableName());

	return copiedQueryRequest;
}