How to use

StructuredQuery

in

com.google.cloud.datastore

private void compareBaseBuilderFields(StructuredQuery<?> query) {
 assertEquals(NAMESPACE, query.getNamespace());
 assertEquals(KIND, query.getKind());
 assertEquals(START_CURSOR, query.getStartCursor());
 assertEquals(END_CURSOR, query.getEndCursor());
 assertEquals(OFFSET, query.getOffset());
 assertEquals(LIMIT, query.getLimit());
 assertEquals(FILTER, query.getFilter());
 assertEquals(ORDER_BY, query.getOrderBy());
}

 @Override
 Query<V> nextQuery(com.google.datastore.v1.RunQueryResponse responsePb) {
  return StructuredQuery.<V>fromPb(getType(), getNamespace(), responsePb.getQuery())
    .nextQuery(responsePb);
 }
}

BuilderImpl(StructuredQuery<V> query) {
 this(query.getType());
 namespace = query.getNamespace();
 kind = query.kind;
 projection.addAll(query.projection);
 filter = query.filter;
 distinctOn.addAll(query.distinctOn);
 orderBy.addAll(query.orderBy);
 startCursor = query.startCursor;
 endCursor = query.endCursor;
 offset = query.offset;
 limit = query.limit;
}

private void compareMergedQuery(StructuredQuery<?> expected, StructuredQuery<?> actual) {
 assertEquals(expected.getKind(), actual.getKind());
 assertEquals(expected.getStartCursor(), actual.getStartCursor());
 assertEquals(expected.getEndCursor(), actual.getEndCursor());
 assertEquals(expected.getOffset(), actual.getOffset());
 assertEquals(expected.getLimit(), actual.getLimit());
 assertEquals(expected.getFilter(), actual.getFilter());
 assertEquals(expected.getOrderBy(), actual.getOrderBy());
 assertEquals(expected.getProjection(), actual.getProjection());
 assertEquals(expected.getDistinctOn(), actual.getDistinctOn());
}

@Test
public void testToBuilder() {
 List<StructuredQuery<?>> queries =
   ImmutableList.<StructuredQuery<?>>of(ENTITY_QUERY, KEY_QUERY, PROJECTION_QUERY);
 for (StructuredQuery<?> query : queries) {
  assertEquals(query, query.toBuilder().build());
 }
}

@Override
public int hashCode() {
 return Objects.hash(
   getNamespace(),
   kind,
   startCursor,
   endCursor,
   offset,
   limit,
   filter,
   orderBy,
   projection,
   distinctOn);
}

private Slice executeSliceQuery(Object[] parameters) {
  EntityQuery.Builder builder = StructuredQuery.newEntityQueryBuilder()
      .setKind(this.datastorePersistentEntity.kindName());
  StructuredQuery query = applyQueryBody(parameters, builder, false);
  List items = this.datastoreTemplate.query((query), (x) -> x);
  Integer limit = (query.getLimit() == null) ? null : query.getLimit() - 1;
  boolean exceedsLimit = false;
  if (limit != null) {
    //for slice queries we retrieve one additional item to check if the next slice exists
    //the additional item will not be converted on read
    exceedsLimit = items.size() > limit;
    if (exceedsLimit) {
      items = items.subList(0, limit);
    }
  }
  ParameterAccessor paramAccessor = new ParametersParameterAccessor(getQueryMethod().getParameters(), parameters);
  Pageable pageable = paramAccessor.getPageable();
  List entities = (List) this.datastoreTemplate
      .convertEntitiesForRead(items.iterator(), this.entityType).stream()
      .map((o) -> this.processRawObjectForProjection((T) o)).collect(Collectors.toList());
  return new SliceImpl(entities, pageable, exceedsLimit);
}

private static <T> String queryKind(Query<T> query) {
 final String kind;
 if (query instanceof StructuredQuery) {
  kind = ((StructuredQuery<T>) query).getKind();
 } else if (query instanceof GqlQuery) {
  kind = "<gql>";
 } else {
  kind = "<unknown>";
 }
 return kind;
}

@Test
public void testToAndFromPb() {
 assertEquals(
   ENTITY_QUERY,
   StructuredQuery.fromPb(
     ResultType.ENTITY, ENTITY_QUERY.getNamespace(), ENTITY_QUERY.toPb()));
 assertEquals(
   KEY_QUERY,
   StructuredQuery.fromPb(ResultType.KEY, KEY_QUERY.getNamespace(), KEY_QUERY.toPb()));
 assertEquals(
   PROJECTION_QUERY,
   StructuredQuery.fromPb(
     ResultType.PROJECTION_ENTITY,
     PROJECTION_QUERY.getNamespace(),
     PROJECTION_QUERY.toPb()));
}

 break;
query = query.toBuilder().setStartCursor(results.getCursorAfter()).build();

@Override
public boolean equals(Object obj) {
 if (obj == this) {
  return true;
 }
 if (!(obj instanceof StructuredQuery)) {
  return false;
 }
 StructuredQuery<?> other = (StructuredQuery<?>) obj;
 return Objects.equals(getNamespace(), other.getNamespace())
   && Objects.equals(kind, other.kind)
   && Objects.equals(startCursor, other.startCursor)
   && Objects.equals(endCursor, other.endCursor)
   && Objects.equals(offset, other.offset)
   && Objects.equals(limit, other.limit)
   && Objects.equals(filter, other.filter)
   && Objects.equals(orderBy, other.orderBy)
   && Objects.equals(projection, other.projection)
   && Objects.equals(distinctOn, other.distinctOn);
}

BuilderImpl(StructuredQuery<V> query) {
 this(query.getType());
 namespace = query.getNamespace();
 kind = query.kind;
 projection.addAll(query.projection);
 filter = query.filter;
 distinctOn.addAll(query.distinctOn);
 orderBy.addAll(query.orderBy);
 startCursor = query.startCursor;
 endCursor = query.endCursor;
 offset = query.offset;
 limit = query.limit;
}

private Slice executeSliceQuery(Object[] parameters) {
  EntityQuery.Builder builder = StructuredQuery.newEntityQueryBuilder()
      .setKind(this.datastorePersistentEntity.kindName());
  StructuredQuery query = applyQueryBody(parameters, builder, false);
  List items = this.datastoreTemplate.query((query), (x) -> x);
  Integer limit = (query.getLimit() == null) ? null : query.getLimit() - 1;
  boolean exceedsLimit = false;
  if (limit != null) {
    //for slice queries we retrieve one additional item to check if the next slice exists
    //the additional item will not be converted on read
    exceedsLimit = items.size() > limit;
    if (exceedsLimit) {
      items = items.subList(0, limit);
    }
  }
  ParameterAccessor paramAccessor = new ParametersParameterAccessor(getQueryMethod().getParameters(), parameters);
  Pageable pageable = paramAccessor.getPageable();
  List entities = (List) this.datastoreTemplate
      .convertEntitiesForRead(items.iterator(), this.entityType).stream()
      .map((o) -> this.processRawObjectForProjection((T) o)).collect(Collectors.toList());
  return new SliceImpl(entities, pageable, exceedsLimit);
}

/**
 * Copy all the behavior characteristics of the orignial query into the builder.
 */
public static <T, B extends StructuredQuery.Builder<T>> B clone(final StructuredQuery<?> orig, final Supplier<B> into) {
  final B builder = into.get();
  builder.setNamespace(orig.getNamespace());
  builder.setEndCursor(orig.getEndCursor());
  builder.setFilter(orig.getFilter());
  builder.setKind(orig.getKind());
  builder.setLimit(orig.getLimit());
  builder.setOffset(orig.getOffset());
  builder.setStartCursor(orig.getStartCursor());
  addOrderBy(builder, orig.getOrderBy());
  return builder;
}

@Override
StructuredQuery<V> nextQuery(com.google.datastore.v1.RunQueryResponse responsePb) {
 Builder<V> builder = toBuilder();
 builder.setStartCursor(new Cursor(responsePb.getBatch().getEndCursor()));
 if (offset > 0 && responsePb.getBatch().getSkippedResults() < offset) {
  builder.setOffset(offset - responsePb.getBatch().getSkippedResults());
 } else {
  builder.setOffset(0);
  if (limit != null) {
   builder.setLimit(limit - responsePb.getBatch().getEntityResultsCount());
  }
 }
 return builder.build();
}

@Override
public int hashCode() {
 return Objects.hash(
   getNamespace(),
   kind,
   startCursor,
   endCursor,
   offset,
   limit,
   filter,
   orderBy,
   projection,
   distinctOn);
}

 @Override
 Query<V> nextQuery(com.google.datastore.v1.RunQueryResponse responsePb) {
  return StructuredQuery.<V>fromPb(getType(), getNamespace(), responsePb.getQuery())
    .nextQuery(responsePb);
 }
}

 break;
query = query.toBuilder().setStartCursor(results.getCursorAfter()).build();

@Override
public boolean equals(Object obj) {
 if (obj == this) {
  return true;
 }
 if (!(obj instanceof StructuredQuery)) {
  return false;
 }
 StructuredQuery<?> other = (StructuredQuery<?>) obj;
 return Objects.equals(getNamespace(), other.getNamespace())
   && Objects.equals(kind, other.kind)
   && Objects.equals(startCursor, other.startCursor)
   && Objects.equals(endCursor, other.endCursor)
   && Objects.equals(offset, other.offset)
   && Objects.equals(limit, other.limit)
   && Objects.equals(filter, other.filter)
   && Objects.equals(orderBy, other.orderBy)
   && Objects.equals(projection, other.projection)
   && Objects.equals(distinctOn, other.distinctOn);
}

@Override
StructuredQuery<V> nextQuery(com.google.datastore.v1.RunQueryResponse responsePb) {
 Builder<V> builder = toBuilder();
 builder.setStartCursor(new Cursor(responsePb.getBatch().getEndCursor()));
 if (offset > 0 && responsePb.getBatch().getSkippedResults() < offset) {
  builder.setOffset(offset - responsePb.getBatch().getSkippedResults());
 } else {
  builder.setOffset(0);
  if (limit != null) {
   builder.setLimit(limit - responsePb.getBatch().getEntityResultsCount());
  }
 }
 return builder.build();
}