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