/** * Return a list of all users. */ public List<User> getAllUsers() { Query<Entity> query = Query.newGqlQueryBuilder(Query.ResultType.ENTITY, "SELECT * FROM " + kind).build(); QueryResults<Entity> results = datastore.run(query); List<User> users = new ArrayList<>(); while (results.hasNext()) { Entity result = results.next(); users.add( new User(result.getString("id"), result.getString("name"), result.getString("email"))); } return users; }
Query<Entity> query1 = Query.newGqlQueryBuilder(ResultType.ENTITY, "select * from " + KIND1) .setNamespace(NAMESPACE) .build(); Query<Entity> scQuery1 = Query.newEntityQueryBuilder() Query<? extends Entity> query2 = Query.newGqlQueryBuilder(ResultType.ENTITY, "select * from " + KIND2 + " order by __key__") .setNamespace(NAMESPACE) .build(); Query<? extends Entity> scQuery2 = Query.newEntityQueryBuilder() .setNamespace(NAMESPACE) .build(); scQuery1 = Query.newEntityQueryBuilder() .setNamespace(NAMESPACE) .build(); Query<Key> scKeyOnlyQuery = Query.newKeyQueryBuilder() .setNamespace(NAMESPACE) .build(); Query<ProjectionEntity> scKeyProjectionQuery = Query.newProjectionEntityQueryBuilder()
Object bindingValue = entry.getValue(); if (bindingValue instanceof Short) { queryBuilder.setBinding(bindingName, (short) bindingValue); } else if (bindingValue instanceof Integer) { queryBuilder.setBinding(bindingName, (int) bindingValue); } else if (bindingValue instanceof Long) { queryBuilder.setBinding(bindingName, (long) bindingValue); } else if (bindingValue instanceof Float) { queryBuilder.setBinding(bindingName, (float) bindingValue); } else if (bindingValue instanceof Double) { queryBuilder.setBinding(bindingName, (double) bindingValue); } else if (bindingValue instanceof Boolean) { queryBuilder.setBinding(bindingName, (boolean) bindingValue); } else if (bindingValue instanceof String) { queryBuilder.setBinding(bindingName, (String) bindingValue); } else if (bindingValue instanceof Calendar) { queryBuilder.setBinding(bindingName, toTimestamp((Calendar) bindingValue)); } else if (bindingValue instanceof Date) { queryBuilder.setBinding(bindingName, toTimestamp((Date) bindingValue)); } else if (bindingValue instanceof LocalDate) { queryBuilder.setBinding(bindingName, ((LocalDate) bindingValue).toString()); } else if (bindingValue instanceof LocalTime) { queryBuilder.setBinding(bindingName, ((LocalTime) bindingValue).format(LocalTimeMapper.FORMATTER)); } else if (bindingValue instanceof LocalDateTime) { queryBuilder.setBinding(bindingName, ((LocalDateTime) bindingValue).format(LocalDateTimeMapper.FORMATTER)); } else if (bindingValue instanceof OffsetDateTime) { queryBuilder.setBinding(bindingName, toTimestamp((OffsetDateTime) bindingValue));
queryBuilder.addBinding((short) binding); } else if (binding instanceof Integer) { queryBuilder.addBinding((int) binding); } else if (binding instanceof Long) { queryBuilder.addBinding((long) binding); } else if (binding instanceof Float) { queryBuilder.addBinding((float) binding); } else if (binding instanceof Double) { queryBuilder.addBinding((double) binding); } else if (binding instanceof Boolean) { queryBuilder.addBinding((boolean) binding); } else if (binding instanceof Character) { queryBuilder.addBinding(String.valueOf((char) binding)); } else if (binding instanceof String) { queryBuilder.addBinding((String) binding); } else if (binding instanceof Calendar) { queryBuilder.addBinding(toTimestamp((Calendar) binding)); } else if (binding instanceof Date) { queryBuilder.addBinding(toTimestamp((Date) binding)); } else if (binding instanceof LocalDate) { queryBuilder.addBinding(((LocalDate) binding).toString()); } else if (binding instanceof LocalTime) { queryBuilder.addBinding(((LocalTime) binding).format(LocalTimeMapper.FORMATTER)); } else if (binding instanceof LocalDateTime) { queryBuilder.addBinding(((LocalDateTime) binding).format(LocalDateTimeMapper.FORMATTER)); } else if (binding instanceof OffsetDateTime) { queryBuilder.addBinding(toTimestamp((OffsetDateTime) binding)); } else if (binding instanceof ZonedDateTime) { queryBuilder.addBinding(toTimestamp((ZonedDateTime) binding));
GqlQuery.Builder<ProjectionEntity> queryBuilder = Query .newGqlQueryBuilder(ResultType.PROJECTION_ENTITY, request.getQuery()); queryBuilder.setNamespace(entityManager.getEffectiveNamespace()); queryBuilder.setAllowLiteral(request.isAllowLiterals()); QueryUtils.applyNamedBindings(queryBuilder, request.getNamedBindings()); QueryUtils.applyPositionalBindings(queryBuilder, request.getPositionalBindings()); GqlQuery<ProjectionEntity> gqlQuery = queryBuilder.build(); QueryResults<ProjectionEntity> results = nativeReader.run(gqlQuery); List<E> entities = new ArrayList<>();
GqlQuery.Builder<Entity> queryBuilder = Query.newGqlQueryBuilder(ResultType.ENTITY, request.getQuery()); queryBuilder.setNamespace(entityManager.getEffectiveNamespace()); queryBuilder.setAllowLiteral(request.isAllowLiterals()); QueryUtils.applyNamedBindings(queryBuilder, request.getNamedBindings()); QueryUtils.applyPositionalBindings(queryBuilder, request.getPositionalBindings()); GqlQuery<Entity> gqlQuery = queryBuilder.build(); QueryResults<Entity> results = nativeReader.run(gqlQuery); List<E> entities = new ArrayList<>();
GqlQuery.Builder<Key> queryBuilder = Query.newGqlQueryBuilder(ResultType.KEY, request.getQuery()); queryBuilder.setNamespace(entityManager.getEffectiveNamespace()); queryBuilder.setAllowLiteral(request.isAllowLiterals()); QueryUtils.applyNamedBindings(queryBuilder, request.getNamedBindings()); QueryUtils.applyPositionalBindings(queryBuilder, request.getPositionalBindings()); GqlQuery<Key> gqlQuery = queryBuilder.build(); QueryResults<Key> results = nativeReader.run(gqlQuery); List<DatastoreKey> entities = new ArrayList<>();
GqlQuery.Builder<Key> gqlQueryBuilder = Query.newGqlQueryBuilder(ResultType.KEY, query); if (limit > 0) { gqlQueryBuilder.setBinding("Limit", limit); gqlQueryBuilder.setBinding("Offset", Cursor.fromUrlSafe(fromCursor.getEncoded())); GqlQuery<Key> gqlQuery = gqlQueryBuilder.build(); Datastore datastore = entityManager.getDatastore(); QueryResults<Key> results = datastore.run(gqlQuery);
@Override public long deleteAll(String kind) { if (Utility.isNullOrEmpty(kind)) { throw new IllegalArgumentException("kind cannot be null or blank"); } String query = "SELECT __key__ FROM " + kind; try { GqlQuery<Key> gqlQuery = Query.newGqlQueryBuilder(Query.ResultType.KEY, query) .setNamespace(getEffectiveNamespace()).build(); QueryResults<Key> keys = datastore.run(gqlQuery); Key[] nativeKeys = new Key[DEFAULT_DELETE_ALL_BATCH_SIZE]; long deleteCount = 0; int i = 0; while (keys.hasNext()) { nativeKeys[i++] = keys.next(); if (i % DEFAULT_DELETE_ALL_BATCH_SIZE == 0) { datastore.delete(nativeKeys); deleteCount += DEFAULT_DELETE_ALL_BATCH_SIZE; i = 0; } } if (i > 0) { datastore.delete(Arrays.copyOfRange(nativeKeys, 0, i)); deleteCount += i; } return deleteCount; } catch (DatastoreException exp) { throw new EntityManagerException(exp); } }
private GqlQuery<? extends BaseEntity> bindArgsToGqlQuery(String gql, List<String> tags, List vals) { Builder builder = GqlQuery.newGqlQueryBuilder(gql); builder.setAllowLiteral(true); if (tags.size() != vals.size()) { throw new DatastoreDataException("Annotated GQL Query Method " + this.queryMethod.getName() + " has " + tags.size() + " tags but a different number of parameter values: " + vals.size()); } for (int i = 0; i < tags.size(); i++) { Object val = vals.get(i); Object boundVal; if (ValueUtil.isCollectionLike(val.getClass())) { boundVal = convertCollectionParamToCompatibleArray((List) ValueUtil.toListIfArray(val)); } else { boundVal = this.datastoreTemplate.getDatastoreEntityConverter().getConversions() .convertOnWriteSingle(val).get(); } DatastoreNativeTypes.bindValueToGqlBuilder(builder, tags.get(i), boundVal); } return builder.build(); }
@Override public List<String> getKinds(boolean excludeSystemKinds) { try { String query = "SELECT __key__ FROM " + ENTITY_KINDS + " ORDER BY __key__"; GqlQuery.Builder<Key> gqlQueryBuilder = Query.newGqlQueryBuilder(ResultType.KEY, query); gqlQueryBuilder.setNamespace(entityManager.getEffectiveNamespace()); GqlQuery<Key> gqlQuery = gqlQueryBuilder.build(); QueryResults<Key> results = entityManager.getDatastore().run(gqlQuery); List<String> kinds = new ArrayList<>(50); while (results.hasNext()) { Key key = results.next(); String kind = key.getName(); if (excludeSystemKinds && kind.startsWith("__")) { continue; } kinds.add(key.getName()); } return kinds; } catch (DatastoreException exp) { throw new EntityManagerException(exp); } }
private GqlQuery<? extends BaseEntity> bindArgsToGqlQuery(String gql, List<String> tags, List vals) { Builder builder = GqlQuery.newGqlQueryBuilder(gql); builder.setAllowLiteral(true); if (tags.size() != vals.size()) { throw new DatastoreDataException("Annotated GQL Query Method " + this.queryMethod.getName() + " has " + tags.size() + " tags but a different number of parameter values: " + vals.size()); } for (int i = 0; i < tags.size(); i++) { Object val = vals.get(i); Object boundVal; if (ValueUtil.isCollectionLike(val.getClass())) { boundVal = convertCollectionParamToCompatibleArray((List) ValueUtil.toListIfArray(val)); } else { boundVal = this.datastoreTemplate.getDatastoreEntityConverter().getConversions() .convertOnWriteSingle(val).get(); } DatastoreNativeTypes.bindValueToGqlBuilder(builder, tags.get(i), boundVal); } return builder.build(); }
private void configAuthenticationDetails(String username) throws ServletException { MemcacheService cache = MemcacheServiceFactory.getMemcacheService(); DatastoreOptions options = DatastoreOptions.newBuilder().build(); Query<?> query = Query.newGqlQueryBuilder("Select passwordSha1 from UserAuthentication " + "where username = @username") .setBinding("username", username) .build(); Datastore datastore = options.getService(); QueryResults<?> results = datastore.run(query); while (results.hasNext()) { Entity currentEntity = (Entity) results.next(); cache.put(username, currentEntity.getString("passwordSha1")); } if(username != null) { String cachePassword = (String)MemcacheServiceFactory.getMemcacheService().get(username); if(cachePassword == null) { throw new ServletException("Invalid User"); } } }
/** * Returns a new {@link GqlQuery} builder. * * <p>Example of creating and running a typed GQL query. * * <pre>{@code * String kind = "my_kind"; * String gqlQuery = "select * from " + kind; * Query<Entity> query = Query.newGqlQueryBuilder(Query.ResultType.ENTITY, gqlQuery).build(); * QueryResults<Entity> results = datastore.run(query); * // Use results * }</pre> * * @see <a href="https://cloud.google.com/datastore/docs/apis/gql/gql_reference">GQL Reference</a> */ public static <V> GqlQuery.Builder<V> newGqlQueryBuilder(ResultType<V> resultType, String gql) { return new GqlQuery.Builder<>(resultType, gql); }
@Test public void testRunGqlQueryNoCasting() { Query<Entity> query1 = Query.newGqlQueryBuilder(ResultType.ENTITY, "select * from " + KIND1).build(); QueryResults<Entity> results1 = datastore.run(query1); assertTrue(results1.hasNext()); Query<? extends Entity> query2 = Query.newGqlQueryBuilder(ResultType.ENTITY, "select * from " + KIND2 + " order by __key__") .build(); QueryResults<? extends Entity> results2 = datastore.run(query2); assertTrue(results2.hasNext()); assertFalse(results2.hasNext()); query1 = Query.newGqlQueryBuilder(ResultType.ENTITY, "select * from bla").build(); results1 = datastore.run(query1); assertFalse(results1.hasNext()); Query.newGqlQueryBuilder(ResultType.KEY, "select __key__ from " + KIND1).build(); QueryResults<Key> keyOnlyResults = datastore.run(keyOnlyQuery); assertTrue(keyOnlyResults.hasNext()); .build(); QueryResults<ProjectionEntity> keyProjectionResult = datastore.run(keyProjectionQuery); assertTrue(keyProjectionResult.hasNext()); .build();
Query<Entity> query1 = (Query<Entity>) Query.newGqlQueryBuilder("select * from " + KIND1).setNamespace(NAMESPACE).build(); Query<Entity> scQuery1 = Query.newEntityQueryBuilder() Query.newGqlQueryBuilder("select * from " + KIND1).setNamespace(NAMESPACE).build();
@Test public void testGqlQueryPagination() throws DatastoreException { List<RunQueryResponse> responses = buildResponsesForQueryPagination(); for (int i = 0; i < responses.size(); i++) { EasyMock.expect(rpcMock.runQuery(EasyMock.anyObject(RunQueryRequest.class))) .andReturn(responses.get(i)); } EasyMock.replay(rpcFactoryMock, rpcMock); Datastore mockDatastore = rpcMockOptions.getService(); QueryResults<Key> results = mockDatastore.run( Query.newGqlQueryBuilder(ResultType.KEY, "select __key__ from *").build()); int count = 0; while (results.hasNext()) { count += 1; results.next(); } assertEquals(count, 5); EasyMock.verify(rpcFactoryMock, rpcMock); }
@Test public void testEventualConsistencyQuery() { ReadOptions readOption = ReadOptions.newBuilder().setReadConsistencyValue(ReadConsistency.EVENTUAL_VALUE).build(); com.google.datastore.v1.GqlQuery query = com.google.datastore.v1.GqlQuery.newBuilder().setQueryString("FROM * SELECT *").build(); RunQueryRequest.Builder expectedRequest = RunQueryRequest.newBuilder() .setReadOptions(readOption) .setGqlQuery(query) .setPartitionId(PartitionId.newBuilder().setProjectId(PROJECT_ID).build()); EasyMock.expect(rpcMock.runQuery(expectedRequest.build())) .andReturn(RunQueryResponse.newBuilder().build()); EasyMock.replay(rpcFactoryMock, rpcMock); Datastore datastore = rpcMockOptions.getService(); datastore.run( Query.newGqlQueryBuilder("FROM * SELECT *").build(), ReadOption.eventualConsistency()); EasyMock.verify(rpcFactoryMock, rpcMock); }
/** * Returns a new {@link GqlQuery} builder. * * <p>Example of creating and running a typed GQL query. * * <pre>{@code * String kind = "my_kind"; * String gqlQuery = "select * from " + kind; * Query<Entity> query = Query.newGqlQueryBuilder(Query.ResultType.ENTITY, gqlQuery).build(); * QueryResults<Entity> results = datastore.run(query); * // Use results * }</pre> * * @see <a href="https://cloud.google.com/datastore/docs/apis/gql/gql_reference">GQL Reference</a> */ public static <V> GqlQuery.Builder<V> newGqlQueryBuilder(ResultType<V> resultType, String gql) { return new GqlQuery.Builder<>(resultType, gql); }
@Test public void testRunGqlQueryWithCasting() { @SuppressWarnings("unchecked") Query<Entity> query1 = (Query<Entity>) Query.newGqlQueryBuilder("select * from " + KIND1).build(); QueryResults<Entity> results1 = datastore.run(query1); assertTrue(results1.hasNext()); assertEquals(ENTITY1, results1.next()); assertFalse(results1.hasNext()); Query<?> query2 = Query.newGqlQueryBuilder("select * from " + KIND1).build(); QueryResults<?> results2 = datastore.run(query2); assertSame(Entity.class, results2.getResultClass()); @SuppressWarnings("unchecked") QueryResults<Entity> results3 = (QueryResults<Entity>) results2; assertTrue(results3.hasNext()); assertEquals(ENTITY1, results3.next()); assertFalse(results3.hasNext()); }