private <T> List<T> makeResultsCopy(QueryResults<T> scResults) { Preconditions.checkNotNull(scResults); List<T> results = new ArrayList<>(); while (scResults.hasNext()) { results.add(scResults.next()); } return results; }
/** Example of running a query to find all entities of one kind. */ // [TARGET run(Query, ReadOption...)] // [VARIABLE "my_kind"] public List<Entity> runQuery(String kind) { // TODO change so that it's not necessary to hold the entities in a list for integration testing // [START runQuery] StructuredQuery<Entity> query = Query.newEntityQueryBuilder().setKind(kind).build(); QueryResults<Entity> results = datastore.run(query); List<Entity> entities = Lists.newArrayList(); while (results.hasNext()) { Entity result = results.next(); // do something with result entities.add(result); } // [END runQuery] return entities; }
/** Example of running a query to find all entities with a matching property value. */ // [TARGET run(Query, ReadOption...)] // [VARIABLE "my_kind"] // [VARIABLE "my_property"] // [VARIABLE "my_value"] public List<Entity> runQueryOnProperty(String kind, String property, String value) { // TODO change so that it's not necessary to hold the entities in a list for integration testing // [START runQueryOnProperty] StructuredQuery<Entity> query = Query.newEntityQueryBuilder() .setKind(kind) .setFilter(PropertyFilter.eq(property, value)) .build(); QueryResults<Entity> results = datastore.run(query); List<Entity> entities = Lists.newArrayList(); while (results.hasNext()) { Entity result = results.next(); // do something with result entities.add(result); } // [END runQueryOnProperty] return entities; } }
/** Deletes all entities in the namespace associated with this {@link RemoteDatastoreHelper}. */ public void deleteNamespace() { StructuredQuery<Key> query = Query.newKeyQueryBuilder().setNamespace(namespace).build(); QueryResults<Key> keys = datastore.run(query); while (keys.hasNext()) { datastore.delete(keys.next()); } }
/** * Finds the ID of the first {@link PortabilityJob} in state {@code jobState} in Datastore, or * null if none found. * * <p>TODO(rtannenbaum): Order by creation time so we can process jobs in a FIFO manner. Trying * to OrderBy.asc("created") currently fails because we don't yet have an index set up. */ @Override public UUID findFirst(JobAuthorization.State jobState) { Query<Key> query = Query.newKeyQueryBuilder() .setKind(KIND) .setFilter(PropertyFilter.eq(PortabilityJob.AUTHORIZATION_STATE, jobState.name())) // .setOrderBy(OrderBy.asc("created")) .setLimit(1) .build(); QueryResults<Key> results = datastore.run(query); if (!results.hasNext()) { return null; } Key key = results.next(); return UUID.fromString(key.getName()); }
@Override public void run(Transaction tx, Key userKey, Void arg) { Entity user = tx.get(userKey); if (user == null) { System.out.println("Nothing to delete, user does not exist."); return; } Query<Key> query = Query.newKeyQueryBuilder() .setNamespace(NAMESPACE) .setKind(COMMENT_KIND) .setFilter(PropertyFilter.hasAncestor(userKey)) .build(); QueryResults<Key> comments = tx.run(query); int count = 0; while (comments.hasNext()) { tx.delete(comments.next()); count++; } tx.delete(userKey); System.out.printf("Deleting user '%s' and %d comment[s].%n", userKey.getName(), count); }
QueryResults<Entity> results = tx.run(query); int resultCount = 0; while (results.hasNext()) { Entity result = results.next(); sortedComments.put(result.getTimestamp("timestamp"), result.getString("content"));
@Test public void testStructuredQueryPagination() 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 datastore = rpcMockOptions.getService(); QueryResults<Key> results = datastore.run(Query.newKeyQueryBuilder().build()); int count = 0; while (results.hasNext()) { count += 1; results.next(); } assertEquals(count, 5); EasyMock.verify(rpcFactoryMock, rpcMock); }
@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); }
@Override public boolean hasNext() { return base.hasNext(); }
@Override public boolean hasNext() { return base.hasNext(); }
@Override public boolean hasNext() { return source.hasNext(); }
@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()); }
/** Example of running a query to find all entities with an ancestor. */ // [TARGET run(Query)] // [VARIABLE "my_parent_key_name"] public List<Entity> run(String parentKeyName) { Datastore datastore = transaction.getDatastore(); // [START run] KeyFactory keyFactory = datastore.newKeyFactory().setKind("ParentKind"); Key parentKey = keyFactory.newKey(parentKeyName); // Build a query Query<Entity> query = Query.newEntityQueryBuilder() .setKind("MyKind") .setFilter(PropertyFilter.hasAncestor(parentKey)) .build(); QueryResults<Entity> results = transaction.run(query); List<Entity> entities = Lists.newArrayList(); while (results.hasNext()) { Entity result = results.next(); // do something with result entities.add(result); } transaction.commit(); // [END run] return entities; }
QueryResults<Entity> results = datastore.run(query); int resultCount = 0; while (results.hasNext()) { results.next(); resultCount++;
Query.newGqlQueryBuilder(ResultType.ENTITY, "select * from " + KIND1).build(); QueryResults<Entity> results1 = datastore.run(query1); assertTrue(results1.hasNext()); assertEquals(ENTITY1, results1.next()); assertFalse(results1.hasNext()); .build(); QueryResults<? extends Entity> results2 = datastore.run(query2); assertTrue(results2.hasNext()); assertEquals(ENTITY2, results2.next()); assertTrue(results2.hasNext()); assertEquals(ENTITY3, results2.next()); assertFalse(results2.hasNext()); assertFalse(results1.hasNext()); assertTrue(keyOnlyResults.hasNext()); assertEquals(KEY1, keyOnlyResults.next()); assertFalse(keyOnlyResults.hasNext()); .build(); QueryResults<ProjectionEntity> keyProjectionResult = datastore.run(keyProjectionQuery); assertTrue(keyProjectionResult.hasNext()); ProjectionEntity projectionEntity = keyProjectionResult.next(); assertEquals(KEY1, projectionEntity.getKey()); assertTrue(projectionEntity.getProperties().isEmpty()); assertFalse(keyProjectionResult.hasNext()); assertTrue(projectionResult.hasNext());
Query.newEntityQueryBuilder().setKind(KIND1).setOrderBy(OrderBy.asc("__key__")).build(); QueryResults<Entity> results1 = datastore.run(query); assertTrue(results1.hasNext()); assertEquals(ENTITY1, results1.next()); assertFalse(results1.hasNext()); assertTrue(results2.hasNext()); assertEquals(ENTITY1.getKey(), results2.next()); assertFalse(results2.hasNext()); assertTrue(results3.hasNext()); ProjectionEntity projectionEntity = results3.next(); assertEquals(ENTITY1.getKey(), projectionEntity.getKey()); assertTrue(projectionEntity.getNames().isEmpty()); assertFalse(results2.hasNext()); assertTrue(results4.hasNext()); ProjectionEntity entity = results4.next(); assertEquals(ENTITY2.getKey(), entity.getKey()); assertEquals(20, entity.getLong("age")); assertEquals(1, entity.getProperties().size()); assertFalse(results4.hasNext());
Transaction transaction = DATASTORE.newTransaction(); QueryResults<Entity> results = transaction.run(query); assertTrue(results.hasNext()); assertEquals(ENTITY2, results.next()); assertFalse(results.hasNext()); transaction.add(ENTITY3); transaction.commit(); assertTrue(results.hasNext()); assertEquals(ENTITY2, results.next()); assertFalse(results.hasNext()); transaction.delete(ENTITY3.getKey());
.build(); QueryResults<Entity> results = datastore.run(query); while (results.hasNext()) { Entity currentEntity = results.next(); System.out.println(currentEntity.getString("name") + ", you're invited to a pizza party!");
@Test public void testTransactionWithQuery() { Query<Entity> query = Query.newEntityQueryBuilder() .setKind(KIND2) .setFilter(PropertyFilter.hasAncestor(KEY2)) .build(); Transaction transaction = datastore.newTransaction(); QueryResults<Entity> results = transaction.run(query); assertEquals(ENTITY2, results.next()); assertFalse(results.hasNext()); transaction.add(ENTITY3); transaction.commit(); assertEquals(ENTITY3, datastore.get(KEY3)); transaction = datastore.newTransaction(); results = transaction.run(query); assertEquals(ENTITY2, results.next()); transaction.delete(ENTITY3.getKey()); // update entity2 during the transaction datastore.put(Entity.newBuilder(ENTITY2).clear().build()); try { transaction.commit(); fail("Expecting a failure"); } catch (DatastoreException expected) { assertEquals("ABORTED", expected.getReason()); } }