@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()); }
return; if (user.contains("contact")) { FullEntity<IncompleteKey> contact = user.getEntity("contact"); String email = contact.getString("email"); String phone = contact.getString("phone"); "User '%s' email is '%s', phone is '%s'.%n", userKey.getName(), email, phone); QueryResults<Entity> results = tx.run(query); int resultCount = 0; while (results.hasNext()) { Entity result = results.next(); sortedComments.put(result.getTimestamp("timestamp"), result.getString("content")); resultCount++; break; query = query.toBuilder().setStartCursor(results.getCursorAfter()).build();
@Test public void testSkippedResults() { Query<Key> query = Query.newKeyQueryBuilder().setOffset(Integer.MAX_VALUE).build(); int numberOfEntities = DATASTORE.run(query).getSkippedResults(); assertEquals(2, numberOfEntities); } }
/** 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()); } }
/** 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; }
Entity johnEntity = datastore.get(key); Entity.newBuilder(janeKey) .set("name", "Jane Doe") .set("age", 44) Key joeKey = keyFactory.newKey("joe.shmoe@gmail.com"); Entity joeEntity = Entity.newBuilder(joeKey) .set("name", "Joe Shmoe") .set("age", 27) Query.newEntityQueryBuilder() .setKind("Person") .setFilter(PropertyFilter.eq("favorite_food", "pizza")) .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() throws InterruptedException { Query<Entity> query = Query.newEntityQueryBuilder() .setKind(KIND2) .setFilter(PropertyFilter.hasAncestor(KEY2)) .setNamespace(NAMESPACE) .build(); 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(); assertEquals(ENTITY3, DATASTORE.get(KEY3)); transaction = DATASTORE.newTransaction(); results = transaction.run(query); assertTrue(results.hasNext()); assertEquals(ENTITY2, results.next()); assertFalse(results.hasNext()); transaction.delete(ENTITY3.getKey()); DATASTORE.put(Entity.newBuilder(ENTITY2).clear().build()); try { transaction.commit();
@Test public void testRunStructuredQuery() { Query<Entity> query = 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()); Query<Key> keyOnlyQuery = Query.newKeyQueryBuilder().setKind(KIND1).build(); QueryResults<Key> results2 = datastore.run(keyOnlyQuery); assertTrue(results2.hasNext()); assertEquals(ENTITY1.getKey(), results2.next()); assertFalse(results2.hasNext()); Query.newProjectionEntityQueryBuilder().setKind(KIND1).setProjection("__key__").build(); QueryResults<ProjectionEntity> results3 = datastore.run(keyOnlyProjectionQuery); 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());
Query<Entity> query = Query.newEntityQueryBuilder() .setKind(_model.getKind()) .setFilter(CompositeFilter.and(PropertyFilter.gt(_model.getExpiry(), 0), PropertyFilter.le(_model.getExpiry(), System.currentTimeMillis()))) .setLimit(_maxResults) .build(); results = _datastore.run(query); LOG.debug("Expiry query no index in {}ms", System.currentTimeMillis()-start); results = _datastore.run(query); while (results.hasNext()) Entity entity = results.next(); info.add(new ExpiryInfo(entity.getString(_model.getId()),entity.getString(_model.getLastNode()), entity.getLong(_model.getExpiry())));
/** 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; }
presults = _datastore.run(query); LOG.debug("Exists query by index in {}ms", System.currentTimeMillis()-start); presults = _datastore.run(query); if (presults.hasNext()) ProjectionEntity pe = presults.next(); return !isExpired(pe.getLong(_model.getExpiry())); Query<Entity> query = Query.newEntityQueryBuilder() .setKind(_model.getKind()) .setFilter(CompositeFilter.and(PropertyFilter.eq(_model.getId(), id), PropertyFilter.eq(_model.getContextPath(), _context.getCanonicalContextPath()), PropertyFilter.eq(_model.getVhost(), _context.getVhost()))) .build(); results = _datastore.run(query); LOG.debug("Exists query no index in {}ms", System.currentTimeMillis()-start); results = _datastore.run(query); if (results.hasNext()) Entity entity = results.next(); return !isExpired(entity.getLong(_model.getExpiry()));
Query<ProjectionEntity> query = Query.newProjectionEntityQueryBuilder() .setKind(_model.getKind()) .setProjection(_model.getId(), _model.getLastNode(), _model.getExpiry()) .setFilter(CompositeFilter.and(PropertyFilter.gt(_model.getExpiry(), 0), PropertyFilter.le(_model.getExpiry(), now))) .setLimit(_maxResults) .build(); presults = _datastore.run(query); LOG.debug("Expiry query by index in {}ms", System.currentTimeMillis()-start); presults = _datastore.run(query); while (presults.hasNext()) ProjectionEntity pe = presults.next(); info.add(new ExpiryInfo(pe.getString(_model.getId()),pe.getString(_model.getLastNode()), pe.getLong(_model.getExpiry())));
@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); }
Query<Entity> query1 = (Query<Entity>) Query.newGqlQueryBuilder("select * from " + KIND1).setNamespace(NAMESPACE).build(); Query<Entity> scQuery1 = Query.newEntityQueryBuilder() .setNamespace(NAMESPACE) .setKind(KIND1) .setFilter(PropertyFilter.hasAncestor(ROOT_KEY)) .build(); Iterator<Entity> results1 = getStronglyConsistentResults(scQuery1, query1); Query.newGqlQueryBuilder("select * from " + KIND1).setNamespace(NAMESPACE).build(); QueryResults<?> results2 = DATASTORE.run(query2); assertSame(Entity.class, results2.getResultClass()); .setNamespace(NAMESPACE) .setKind(KIND1) .setFilter(PropertyFilter.hasAncestor(ROOT_KEY)) .build();
Query<Key> q = Query.newKeyQueryBuilder() .setKind(_model.getKind()) .setFilter(PropertyFilter.eq(_model.getId(), s)) .build(); QueryResults<Key> res = _datastore.run(q); if (!res.hasNext())
@Override public boolean hasNext() { return base.hasNext(); }
@Override public ResultWithCursor<T> next() { final T next = base.next(); final Cursor cursor = base.getCursorAfter(); return new ResultWithCursor<>(next, cursor); } }
@Override public Key<T> next() { final com.google.cloud.datastore.Key key = source.next(); return Key.create(key); }