Java QueryResultBatch类代码示例

import com.google.datastore.v1.QueryResultBatch; //导入依赖的package包/类
/**
 * Cloud Datastore system tables with statistics are periodically updated. This method fetches
 * the latest timestamp (in microseconds) of statistics update using the {@code __Stat_Total__}
 * table.
 */
private static long queryLatestStatisticsTimestamp(Datastore datastore,
    @Nullable String namespace)  throws DatastoreException {
  Query.Builder query = Query.newBuilder();
  // Note: namespace either being null or empty represents the default namespace, in which
  // case we treat it as not provided by the user.
  if (Strings.isNullOrEmpty(namespace)) {
    query.addKindBuilder().setName("__Stat_Total__");
  } else {
    query.addKindBuilder().setName("__Stat_Ns_Total__");
  }
  query.addOrder(makeOrder("timestamp", DESCENDING));
  query.setLimit(Int32Value.newBuilder().setValue(1));
  RunQueryRequest request = makeRequest(query.build(), namespace);

  RunQueryResponse response = datastore.runQuery(request);
  QueryResultBatch batch = response.getBatch();
  if (batch.getEntityResultsCount() == 0) {
    throw new NoSuchElementException(
        "Datastore total statistics unavailable");
  }
  Entity entity = batch.getEntityResults(0).getEntity();
  return entity.getProperties().get("timestamp").getTimestampValue().getSeconds() * 1000000;
}
 

import com.google.datastore.v1.QueryResultBatch; //导入依赖的package包/类
/**
 * Run a query on the datastore.
 *
 * @return The entities returned by the query.
 * @throws DatastoreException on error
 */
private List<Entity> runQuery(Query query) throws DatastoreException {
  RunQueryRequest.Builder request = RunQueryRequest.newBuilder();
  request.setQuery(query);
  RunQueryResponse response = datastore.runQuery(request.build());

  if (response.getBatch().getMoreResults() == QueryResultBatch.MoreResultsType.NOT_FINISHED) {
    System.err.println("WARNING: partial results\n");
  }
  List<EntityResult> results = response.getBatch().getEntityResultsList();
  List<Entity> entities = new ArrayList<Entity>(results.size());
  for (EntityResult result : results) {
    entities.add(result.getEntity());
  }
  return entities;
}
 

import com.google.datastore.v1.QueryResultBatch; //导入依赖的package包/类
/**
 * Gets a list of split keys given a desired number of splits.
 *
 * <p>This list will contain multiple split keys for each split. Only a single split key
 * will be chosen as the split point, however providing multiple keys allows for more uniform
 * sharding.
 *
 * @param numSplits the number of desired splits.
 * @param query the user query.
 * @param partition the partition to run the query in.
 * @param datastore the datastore containing the data.
 * @throws DatastoreException if there was an error when executing the datastore query.
 */
private List<Key> getScatterKeys(
    int numSplits, Query query, PartitionId partition, Datastore datastore)
    throws DatastoreException {
  Query.Builder scatterPointQuery = createScatterQuery(query, numSplits);

  List<Key> keySplits = new ArrayList<Key>();

  QueryResultBatch batch;
  do {
    RunQueryRequest scatterRequest =
        RunQueryRequest.newBuilder()
            .setPartitionId(partition)
            .setQuery(scatterPointQuery)
            .build();
    batch = datastore.runQuery(scatterRequest).getBatch();
    for (EntityResult result : batch.getEntityResultsList()) {
      keySplits.add(result.getEntity().getKey());
    }
    scatterPointQuery.setStartCursor(batch.getEndCursor());
    scatterPointQuery.getLimitBuilder().setValue(
        scatterPointQuery.getLimit().getValue() - batch.getEntityResultsCount());
  } while (batch.getMoreResults() == MoreResultsType.NOT_FINISHED);
  Collections.sort(keySplits, DatastoreHelper.getKeyComparator());
  return keySplits;
}
 

import com.google.datastore.v1.QueryResultBatch; //导入依赖的package包/类
/**
 * Get the estimated size of the data returned by the given query.
 *
 * <p>Cloud Datastore provides no way to get a good estimate of how large the result of a query
 * entity kind being queried, using the __Stat_Kind__ system table, assuming exactly 1 kind
 * is specified in the query.
 *
 * <p>See https://cloud.google.com/datastore/docs/concepts/stats.
 */
static long getEstimatedSizeBytes(Datastore datastore, Query query, @Nullable String namespace)
    throws DatastoreException {
  String ourKind = query.getKind(0).getName();
  long latestTimestamp = queryLatestStatisticsTimestamp(datastore, namespace);
  LOG.info("Latest stats timestamp for kind {} is {}", ourKind, latestTimestamp);

  Query.Builder queryBuilder = Query.newBuilder();
  if (Strings.isNullOrEmpty(namespace)) {
    queryBuilder.addKindBuilder().setName("__Stat_Kind__");
  } else {
    queryBuilder.addKindBuilder().setName("__Stat_Ns_Kind__");
  }

  queryBuilder.setFilter(makeAndFilter(
      makeFilter("kind_name", EQUAL, makeValue(ourKind).build()).build(),
      makeFilter("timestamp", EQUAL, makeValue(latestTimestamp).build()).build()));

  RunQueryRequest request = makeRequest(queryBuilder.build(), namespace);

  long now = System.currentTimeMillis();
  RunQueryResponse response = datastore.runQuery(request);
  LOG.debug("Query for per-kind statistics took {}ms", System.currentTimeMillis() - now);

  QueryResultBatch batch = response.getBatch();
  if (batch.getEntityResultsCount() == 0) {
    throw new NoSuchElementException(
        "Datastore statistics for kind " + ourKind + " unavailable");
  }
  Entity entity = batch.getEntityResults(0).getEntity();
  return entity.getProperties().get("entity_bytes").getIntegerValue();
}
 

import com.google.datastore.v1.QueryResultBatch; //导入依赖的package包/类
/**
 * A helper function that creates mock {@link Entity} results in response to a query. Always
 * indicates that more results are available, unless the batch is limited to fewer than
 * {@link DatastoreV1.Read#QUERY_BATCH_LIMIT} results.
 */
private static RunQueryResponse mockResponseForQuery(Query q) {
  // Every query DatastoreV1 sends should have a limit.
  assertTrue(q.hasLimit());

  // The limit should be in the range [1, QUERY_BATCH_LIMIT]
  int limit = q.getLimit().getValue();
  assertThat(limit, greaterThanOrEqualTo(1));
  assertThat(limit, lessThanOrEqualTo(QUERY_BATCH_LIMIT));

  // Create the requested number of entities.
  List<EntityResult> entities = new ArrayList<>(limit);
  for (int i = 0; i < limit; ++i) {
    entities.add(
        EntityResult.newBuilder()
            .setEntity(Entity.newBuilder().setKey(makeKey("key" + i, i + 1)))
            .build());
  }

  // Fill out the other parameters on the returned result batch.
  RunQueryResponse.Builder ret = RunQueryResponse.newBuilder();
  ret.getBatchBuilder()
      .addAllEntityResults(entities)
      .setEntityResultType(EntityResult.ResultType.FULL)
      .setMoreResults(
          limit == QUERY_BATCH_LIMIT
              ? QueryResultBatch.MoreResultsType.NOT_FINISHED
              : QueryResultBatch.MoreResultsType.NO_MORE_RESULTS);

  return ret.build();
}
 

import com.google.datastore.v1.QueryResultBatch; //导入依赖的package包/类
/** Builds a per-kind statistics response with the given entity size. */
private static RunQueryResponse makeStatKindResponse(long entitySizeInBytes) {
  RunQueryResponse.Builder statKindResponse = RunQueryResponse.newBuilder();
  Entity.Builder entity = Entity.newBuilder();
  entity.setKey(makeKey("dummyKind", "dummyId"));
  entity.putProperties("entity_bytes", makeValue(entitySizeInBytes).build());
  EntityResult.Builder entityResult = EntityResult.newBuilder();
  entityResult.setEntity(entity);
  QueryResultBatch.Builder batch = QueryResultBatch.newBuilder();
  batch.addEntityResults(entityResult);
  statKindResponse.setBatch(batch);
  return statKindResponse.build();
}
 

import com.google.datastore.v1.QueryResultBatch; //导入依赖的package包/类
/** Builds a response of the given timestamp. */
private static RunQueryResponse makeLatestTimestampResponse(long timestamp) {
  RunQueryResponse.Builder timestampResponse = RunQueryResponse.newBuilder();
  Entity.Builder entity = Entity.newBuilder();
  entity.setKey(makeKey("dummyKind", "dummyId"));
  entity.putProperties("timestamp", makeValue(new Date(timestamp * 1000)).build());
  EntityResult.Builder entityResult = EntityResult.newBuilder();
  entityResult.setEntity(entity);
  QueryResultBatch.Builder batch = QueryResultBatch.newBuilder();
  batch.addEntityResults(entityResult);
  timestampResponse.setBatch(batch);
  return timestampResponse.build();
}
 

import com.google.datastore.v1.QueryResultBatch; //导入依赖的package包/类
@Test
public void runQuery() throws Exception {
  RunQueryRequest.Builder request = RunQueryRequest.newBuilder();
  request.getQueryBuilder();
  RunQueryResponse.Builder response = RunQueryResponse.newBuilder();
  response.getBatchBuilder()
      .setEntityResultType(EntityResult.ResultType.FULL)
      .setMoreResults(QueryResultBatch.MoreResultsType.NOT_FINISHED);
  expectRpc("runQuery", request.build(), response.build());
}
 

import com.google.datastore.v1.QueryResultBatch; //导入依赖的package包/类
/** Read and output entities for the given query. */
@ProcessElement
public void processElement(ProcessContext context) throws Exception {
  Query query = context.element();
  String namespace = options.getNamespace();
  int userLimit = query.hasLimit()
      ? query.getLimit().getValue() : Integer.MAX_VALUE;

  boolean moreResults = true;
  QueryResultBatch currentBatch = null;

  while (moreResults) {
    Query.Builder queryBuilder = query.toBuilder().clone();
    queryBuilder.setLimit(Int32Value.newBuilder().setValue(
        Math.min(userLimit, QUERY_BATCH_LIMIT)));

    if (currentBatch != null && !currentBatch.getEndCursor().isEmpty()) {
      queryBuilder.setStartCursor(currentBatch.getEndCursor());
    }

    RunQueryRequest request = makeRequest(queryBuilder.build(), namespace);
    RunQueryResponse response = runQueryWithRetries(request);

    currentBatch = response.getBatch();

    // MORE_RESULTS_AFTER_LIMIT is not implemented yet:
    // https://groups.google.com/forum/#!topic/gcd-discuss/iNs6M1jA2Vw, so
    // use result count to determine if more results might exist.
    int numFetch = currentBatch.getEntityResultsCount();
    if (query.hasLimit()) {
      verify(userLimit >= numFetch,
          "Expected userLimit %s >= numFetch %s, because query limit %s must be <= userLimit",
          userLimit, numFetch, query.getLimit());
      userLimit -= numFetch;
    }

    // output all the entities from the current batch.
    for (EntityResult entityResult : currentBatch.getEntityResultsList()) {
      context.output(entityResult.getEntity());
    }

    // Check if we have more entities to be read.
    moreResults =
        // User-limit does not exist (so userLimit == MAX_VALUE) and/or has not been satisfied
        (userLimit > 0)
            // All indications from the API are that there are/may be more results.
            && ((numFetch == QUERY_BATCH_LIMIT)
            || (currentBatch.getMoreResults() == NOT_FINISHED));
  }
}