Java QuerySpec类代码示例

import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec; //导入依赖的package包/类
private static Page<Item, QueryOutcome> queryGSI(String appid, Pager p) {
	Pager pager = (p != null) ? p : new Pager();
	Index index = getSharedIndex();
	QuerySpec spec = new QuerySpec().
			withMaxPageSize(pager.getLimit()).
			withMaxResultSize(pager.getLimit()).
			withKeyConditionExpression(Config._APPID + " = :aid").
			withValueMap(new ValueMap().withString(":aid", appid));

	if (!StringUtils.isBlank(pager.getLastKey())) {
		spec = spec.withExclusiveStartKey(new KeyAttribute(Config._APPID, appid),	// HASH/PARTITION KEY
				new KeyAttribute(Config._ID, pager.getLastKey()), // RANGE/SORT KEY
				new KeyAttribute(Config._KEY, getKeyForAppid(pager.getLastKey(), appid))); // TABLE PRIMARY KEY
	}
	return index != null ? index.query(spec).firstPage() : null;
}
 

import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec; //导入依赖的package包/类
@Override public boolean queryRelationExists(String relationHashKey, String relationRangeKey) {

    Table table = dynamoDB.getTable(this.groupGraphTableName);

    QuerySpec querySpec = new QuerySpec()
        .withKeyConditionExpression("subject = :k_subject and object_relation = :k_object_relation")
        .withValueMap(new ValueMap()
            .withString(":k_subject", relationHashKey)
            .withString(":k_object_relation", relationRangeKey)
        )
        .withMaxResultSize(1)
        .withConsistentRead(true);

    DynamoDbCommand<ItemCollection<QueryOutcome>> cmd = new DynamoDbCommand<>("queryRelation",
        () -> queryTable(table, querySpec),
        () -> {
          throw new RuntimeException("queryRelation");
        },
        dynamodbNamespaceGraphQueryHystrix,
        metrics);

    // can't use getLastLowLevelResult directly; it's false unless the outcome is iterated first :|
    return cmd.execute().iterator().hasNext();
  }
 

import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec; //导入依赖的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.document.spec.QuerySpec; //导入依赖的package包/类
private static void findRepliesUsingAFilterExpression(String forumName, String threadSubject) {

        Table table = dynamoDB.getTable(tableName);
        
        String replyId = forumName + "#" + threadSubject;

        QuerySpec spec = new QuerySpec()
            .withProjectionExpression("Message, ReplyDateTime, PostedBy")
            .withKeyConditionExpression("Id = :v_id")
            .withFilterExpression("PostedBy = :v_postedby")
            .withValueMap(new ValueMap()
                .withString(":v_id", replyId)
                .withString(":v_postedby", "User B"));
        
        ItemCollection<QueryOutcome> items = table.query(spec);

        System.out.println("\nfindRepliesUsingAFilterExpression results:");
        Iterator<Item> iterator = items.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next().toJSONPretty());
        }    
     }
 

import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec; //导入依赖的package包/类
@Override public Optional<Group> loadByKey(String key) {
  Table table = dynamoDB.getTable(this.groupTableName);

  QuerySpec querySpec = new QuerySpec()
      .withKeyConditionExpression(HASH_KEY + " = :k_app_key")
      .withValueMap(new ValueMap()
          .withString(":k_app_key", key)
      )
      .withMaxResultSize(1)
      .withConsistentRead(true);

  DynamoDbCommand<ItemCollection<QueryOutcome>> cmd = new DynamoDbCommand<>("loadByKey",
      () -> queryTable(table, querySpec),
      () -> {
        throw new RuntimeException("loadByKey");
      },
      dynamodbNamespaceGraphQueryHystrix,
      metrics);

  final ItemCollection<QueryOutcome> items = cmd.execute();
  final IteratorSupport<Item, QueryOutcome> iterator = items.iterator();
  if (iterator.hasNext()) {
    return Optional.of(GroupSupport.toGroup(iterator.next().getString("json")));
  }

  return Optional.empty();
}
 

import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec; //导入依赖的package包/类
@Override public List<Feature> loadFeatures(String group) {
  logger.info("{}", kvp("op", "loadFeatures", "group", group));
  List<Feature> features = Lists.newArrayList();

  Table table = dynamoDB.getTable(featureTableName);

  QuerySpec querySpec = new QuerySpec()
      .withKeyConditionExpression(HASH_KEY + " = :k_" + HASH_KEY)
      .withValueMap(new ValueMap().withString(":k_" + HASH_KEY, group))
      .withConsistentRead(true);

  DynamoDbCommand<ItemCollection<QueryOutcome>> cmd = new DynamoDbCommand<>("loadFeatures",
      () -> queryTable(table, querySpec),
      () -> {
        throw new RuntimeException("loadFeatureById");
      },
      hystrixReadConfiguration,
      metrics);

  ItemCollection<QueryOutcome> items = cmd.execute();

  for (Page<Item, QueryOutcome> page : items.pages()) {
    page.forEach(item -> features.add(FeatureSupport.toFeature(item.getString("json"))));
  }

  return features;
}
 

import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec; //导入依赖的package包/类
@Override
public QueryItemsBuilder<T> queryItems(Object hk, PageIterator pageIterator) {
    if ( null == _convertMarker ) {
        throw new IllegalStateException("Index must first be initialized with ConvertMarker");
    }
    QuerySpec spec = withMarker(new QuerySpec().withHashKey(_hkName, hk), pageIterator, hk);
    return new QueryItemsBuilderImpl<T>(spec, _rkName, pageIterator, this::countItems, this::listItems, _clazz, _encryption);
}
 

import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec; //导入依赖的package包/类
private QuerySpec withMarker(QuerySpec spec, PageIterator pageIterator, Object hk) {
    if ( null != pageIterator.getMarker() ) {
        spec.withExclusiveStartKey(fromMarker(hk, pageIterator.getMarker()));
    }
    int pageSize = pageIterator.getPageSize();
    if ( pageSize != Integer.MAX_VALUE ) {
        spec.withMaxPageSize(pageSize);
    }
    return spec.withScanIndexForward(pageIterator.isForward());
}
 

import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec; //导入依赖的package包/类
public QueryItemsBuilderImpl(QuerySpec spec, String rangeKeyName, PageIterator iter, CountItems countItems, ListItems listItems, Class<T> clazz, DDBEncryption encryption) {
    _spec = spec;
    _rkName = rangeKeyName;
    _iter = iter;
    _countItems = countItems;
    _listItems = listItems;
    _clazz = clazz;
    _encryption = encryption;
}
 

import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec; //导入依赖的package包/类
@Override
public List<String> retrieveRecordsForProvince(String dataSetLabel, String infoSetTag, Province province, Locale locale) {
    if (!useDynamoDirect) {
        URI uriToCall = baseBuilder()
                .path("/records/{dataset}/{infoSet}")
                .queryParam("province", province.toString())
                .queryParam("locale", locale.toLanguageTag())
                .buildAndExpand(dataSetLabel, infoSetTag).toUri();

        log.info("assembled URI to get records = {}", uriToCall.toString());

        return getFromUri(uriToCall);
    } else {
        DynamoDB dynamoDB = new DynamoDB(dynamoDBClient);
        Table geoApiTable = dynamoDB.getTable("geo_" + dataSetLabel.toLowerCase());
        log.info("querying from table, name: {}, number of rows: {}",
                "geo_" + dataSetLabel.toLowerCase(), geoApiTable.describe().toString());
        log.info("looking for province, with name: {}, on infoSet: {}", province.name(), infoSetTag);

        Index provinceIndex = geoApiTable.getIndex("lowestGeoInfo"); // figure out how to adapt when province != lowest
        QuerySpec querySpec = new QuerySpec()
                .withKeyConditionExpression("province = :prv and infoTag = :info")
                .withValueMap(new ValueMap()
                        .withString(":prv", province.name())
                        .withString(":info", infoSetTag));

        try {
            ItemCollection<QueryOutcome> records = provinceIndex.query(querySpec);
            List<String> result = new ArrayList<>();
            records.iterator().forEachRemaining(i -> result.add(i.getString("description")));
            log.info("iterated through the results, number of results: {}", result.size());
            return result;
        } catch (Exception e) {
            log.error("Error!", e);
            throw new IllegalArgumentException("No results for that dataset, province and field");
        }
    }
}
 

import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec; //导入依赖的package包/类
private static <T extends Item> void addRangeKeyConditionToQuerySpec(final QuerySpec querySpec,
        final CompoundAttributeQuery compoundAttributeQuery, final Class<T> itemClass) {
    final String supportingConditionStringValue = compoundAttributeQuery.getSupportingCondition().getValues().iterator()
            .next();
    final Operators comparisonOperator = compoundAttributeQuery.getSupportingCondition().getComparisonOperator();
    final Class<?> supportingAttributeType = compoundAttributeQuery.getSupportingAttributeType(itemClass);

    try {
        final Object supportingConditionValue = supportingAttributeType.getConstructor(String.class).newInstance(supportingConditionStringValue);

        final RangeKeyCondition rangeKeyCondition = RangeKeyConditionBuilder
                .build(compoundAttributeQuery.getSupportingAttributeName(), supportingConditionValue, comparisonOperator);
        querySpec.withRangeKeyCondition(rangeKeyCondition);
    } catch (final Exception e) {
        throw new PersistenceResourceFailureException(
                String.format("Could not add range key condition for query: %s on item %s.", compoundAttributeQuery,
                        itemClass.getSimpleName()),
                e);
    }
}
 

import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec; //导入依赖的package包/类
@Test
public void shouldBuild_withAttributeQuery() {
    // Given
    final String attributeName = randomString(10);
    final Condition mockCondition = randomCondition(1);
    final String expectedValue = mockCondition.getValues().iterator().next();
    final AttributeQuery mockAttributeQuery = mock(AttributeQuery.class);

    when(mockAttributeQuery.getAttributeName()).thenReturn(attributeName);
    when(mockAttributeQuery.getCondition()).thenReturn(mockCondition);

    // When
    final QuerySpec querySpec = QuerySpecBuilder.build(mockAttributeQuery, StubItem.class);

    // Then
    assertEquals(attributeName, querySpec.getHashKey().getName());
    assertEquals(expectedValue, querySpec.getHashKey().getValue());
    assertNull(querySpec.getRangeKeyCondition());
}
 

import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec; //导入依赖的package包/类
@Test
public void shouldQueryTable() {
    // Given
    final ItemId itemId = new ItemId(randomId());

    final ItemConfiguration itemConfiguration = new ItemConfiguration(StubItem.class, tableName);
    final Collection<ItemConfiguration> itemConfigurations = Arrays.asList(itemConfiguration);
    when(mockDatabaseSchemaHolder.itemConfigurations()).thenReturn(itemConfigurations);

    final Table mockTable = mock(Table.class);
    when(mockDynamoDBClient.getTable(any(String.class))).thenReturn(mockTable);

    final DynamoDocumentStoreTemplate dynamoDocumentStoreTemplate = new DynamoDocumentStoreTemplate(
            mockDatabaseSchemaHolder);
    dynamoDocumentStoreTemplate.initialize(mockAmazonDynamoDbClient);

    final ItemCollection<QueryOutcome> outcome = mock(ItemCollection.class);
    when(mockTable.query(any(QuerySpec.class))).thenReturn(outcome);
    // when
    dynamoDocumentStoreTemplate.fetch(new AttributeQuery("id", new Condition(Operators.EQUALS, itemId.value())),
            StubItem.class);
    // then
    verify(mockTable.query(any(QuerySpec.class)));
}
 

import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec; //导入依赖的package包/类
public static <T extends Item> QuerySpec build(final AttributeQuery attributeQuery, final Class<T> itemClass) {
    if (CompoundAttributeQuery.class.isAssignableFrom(attributeQuery.getClass())) {
        final CompoundAttributeQuery compoundAttributeQuery = (CompoundAttributeQuery) attributeQuery;
        return buildWithHashAndRangeKey(compoundAttributeQuery, itemClass);
    }

    return buildWithHashKey(attributeQuery);
}
 

import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec; //导入依赖的package包/类
private static <T extends Item> QuerySpec buildWithHashAndRangeKey(
        final CompoundAttributeQuery compoundAttributeQuery, final Class<T> itemClass) {
    final Set<String> supportingConditionValues = compoundAttributeQuery.getSupportingCondition().getValues();
    validateSupportingConditionValues(supportingConditionValues);

    final QuerySpec querySpec = buildWithHashKey(compoundAttributeQuery);
    addRangeKeyConditionToQuerySpec(querySpec, compoundAttributeQuery, itemClass);

    return querySpec;
}