Refine search
/** 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; } }
@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());
Query.newEntityQueryBuilder() .setKind(KIND1) .setFilter(PropertyFilter.hasAncestor(ROOT_KEY)) assertFalse(results1.hasNext()); Query<Key> keyOnlyQuery = Query.newKeyQueryBuilder().setKind(KIND1).build(); .setFilter(PropertyFilter.hasAncestor(ROOT_KEY)) .build(); .setFilter(PropertyFilter.hasAncestor(ROOT_KEY)) .setProjection("__key__") .build(); .setKind(KIND2) .setProjection("age") .setFilter(PropertyFilter.gt("age", 18)) .setDistinctOn("age") .setOrderBy(OrderBy.asc("age")) .setFilter(PropertyFilter.hasAncestor(ROOT_KEY)) .setProjection("age") .setFilter(PropertyFilter.gt("age", 18)) .setDistinctOn("age") .setOrderBy(OrderBy.asc("age"))
KeyFactory keyFactory = datastore.newKeyFactory().setKind("Person"); Key key = keyFactory.newKey("john.doe@gmail.com"); Entity entity = .set("favorite_food", "pizza") .build(); datastore.put(entity); Entity johnEntity = datastore.get(key); 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!");
/** * 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()); }
/** 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; }
Map<Timestamp, String> sortedComments = new TreeMap<>(); StructuredQuery<Entity> query = Query.newEntityQueryBuilder() .setNamespace(NAMESPACE) .setKind(COMMENT_KIND) .setFilter(PropertyFilter.hasAncestor(userKey)) .setLimit(limit) .build(); 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();
@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); }
@Test public void testRunGqlQueryNoCasting() throws InterruptedException { Query<Entity> query1 = Query.newGqlQueryBuilder(ResultType.ENTITY, "select * from " + KIND1) .setNamespace(NAMESPACE) .build(); Query<Entity> scQuery1 = Query.newEntityQueryBuilder() .setNamespace(NAMESPACE) .setKind(KIND1) .setFilter(PropertyFilter.hasAncestor(ROOT_KEY)) assertFalse(results1.hasNext()); .setFilter(PropertyFilter.hasAncestor(ROOT_KEY)) .setFilter(PropertyFilter.hasAncestor(ROOT_KEY)) .setFilter(PropertyFilter.hasAncestor(ROOT_KEY)) .setKind(KIND1) .build(); .setNamespace(NAMESPACE) .setKind(KIND1) .setFilter(PropertyFilter.hasAncestor(ROOT_KEY)) .build();
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())
private EntityQuery.Builder backfillQueryBuilder(boolean showAll, Filter... filters) { final EntityQuery.Builder queryBuilder = Query.newEntityQueryBuilder().setKind(KIND_BACKFILL); final List<Filter> andedFilters = Lists.newArrayList(filters); if (!showAll) { andedFilters.add(PropertyFilter.eq(PROPERTY_ALL_TRIGGERED, false)); andedFilters.add(PropertyFilter.eq(PROPERTY_HALTED, false)); } if (!andedFilters.isEmpty()) { final Filter head = andedFilters.get(0); final Filter[] tail = andedFilters.stream().skip(1).toArray(Filter[]::new); queryBuilder.setFilter(CompositeFilter.and(head, tail)); } return queryBuilder; }
/** * Check to see if indexes are available, in which case * we can do more performant queries. * @return <code>true</code> if indexes are available */ protected boolean checkIndexes() { try { Query<ProjectionEntity> query = Query.newProjectionEntityQueryBuilder() .setKind(_model.getKind()) .setProjection(_model.getExpiry()) .setFilter(PropertyFilter.eq(_model.getId(), "-")) .build(); _datastore.run(query); return true; } catch (DatastoreException e) { //need to assume that the problem is the index doesn't exist, because there //is no specific code for that if (LOG.isDebugEnabled()) LOG.debug("Check for indexes", e); return false; } }
this.datastoreMappingContext.getPersistentEntity(example.getProbeType()); StructuredQuery.Builder builder = keyQuery ? Query.newKeyQueryBuilder() : Query.newEntityQueryBuilder(); builder.setKind(persistentEntity.kindName()); filters.add(StructuredQuery.PropertyFilter.eq(fieldName, value));
static Filter fromPb(com.google.datastore.v1.Filter filterPb) { switch (filterPb.getFilterTypeCase()) { case COMPOSITE_FILTER: return CompositeFilter.fromPb(filterPb.getCompositeFilter()); case PROPERTY_FILTER: return PropertyFilter.fromPb(filterPb.getPropertyFilter()); default: throw new AssertionError("Unexpected enum value " + filterPb.getFilterTypeCase()); } } }
static PropertyFilter fromPb(com.google.datastore.v1.PropertyFilter propertyFilterPb) { String property = propertyFilterPb.getProperty().getName(); Operator operator = Operator.fromPb(propertyFilterPb.getOp()); Value<?> value = Value.fromPb(propertyFilterPb.getValue()); return new PropertyFilter(property, operator, value); }
public static PropertyFilter lt(String property, boolean value) { return new PropertyFilter(property, Operator.LESS_THAN, of(value)); }
public static PropertyFilter lt(String property, Key value) { return new PropertyFilter(property, Operator.LESS_THAN, of(value)); }
public static PropertyFilter le(String property, boolean value) { return new PropertyFilter(property, Operator.LESS_THAN_OR_EQUAL, of(value)); }
public static PropertyFilter le(String property, Timestamp value) { return new PropertyFilter(property, Operator.LESS_THAN_OR_EQUAL, of(value)); }