/** 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; }
Query.newEntityQueryBuilder() .setNamespace(NAMESPACE) .setKind(COMMENT_KIND) .setFilter(PropertyFilter.hasAncestor(userKey)) .setLimit(limit)
/** 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; } }
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; }
Set<WorkflowId> enabled() throws IOException { final EntityQuery queryWorkflows = EntityQuery.newEntityQueryBuilder().setKind(KIND_WORKFLOW).build(); final Set<WorkflowId> enabledWorkflows = Sets.newHashSet(); datastore.query(queryWorkflows, workflow -> { final boolean enabled = workflow.contains(PROPERTY_WORKFLOW_ENABLED) && workflow.getBoolean(PROPERTY_WORKFLOW_ENABLED); if (enabled) { enabledWorkflows.add(parseWorkflowId(workflow)); } }); return enabledWorkflows; }
List<Resource> getResources() throws IOException { final EntityQuery query = Query.newEntityQueryBuilder().setKind(KIND_COUNTER_LIMIT).build(); final List<Resource> resources = Lists.newArrayList(); datastore.query(query, entity -> resources.add(entityToResource(entity))); return resources; }
Map<WorkflowInstance, RunState> readActiveStates(String componentId) throws IOException { final EntityQuery query = Query.newEntityQueryBuilder().setKind(KIND_ACTIVE_WORKFLOW_INSTANCE) .setFilter(PropertyFilter.eq(PROPERTY_COMPONENT, componentId)) .build(); return queryActiveStates(query); }
@Override public <T> Collection<T> findAll(Class<T> entityClass, DatastoreQueryOptions queryOptions) { DatastorePersistentEntity<?> persistentEntity = this.datastoreMappingContext.getPersistentEntity(entityClass); EntityQuery.Builder builder = Query.newEntityQueryBuilder() .setKind(persistentEntity.kindName()); applyQueryOptions(builder, queryOptions, persistentEntity); return convertEntitiesForRead(getDatastoreReadWriter().run(builder.build()), entityClass); }
@Override public <T> Collection<T> findAll(Class<T> entityClass, DatastoreQueryOptions queryOptions) { DatastorePersistentEntity<?> persistentEntity = this.datastoreMappingContext.getPersistentEntity(entityClass); EntityQuery.Builder builder = Query.newEntityQueryBuilder() .setKind(persistentEntity.kindName()); applyQueryOptions(builder, queryOptions, persistentEntity); return convertEntitiesForRead(getDatastoreReadWriter().run(builder.build()), entityClass); }
public Map<WorkflowInstance, RunState> activeStatesByTriggerId( String triggerId) throws IOException { final EntityQuery query = Query.newEntityQueryBuilder().setKind(KIND_ACTIVE_WORKFLOW_INSTANCE) .setFilter(PropertyFilter.eq(PROPERTY_STATE_TRIGGER_ID, triggerId)) .build(); return queryActiveStates(query); }
/** * Returns a list of all task entities in ascending order of creation time. * * @throws DatastoreException if the query fails */ Iterator<Entity> listTasks() { Query<Entity> query = Query.newEntityQueryBuilder().setKind("Task").setOrderBy(OrderBy.asc("created")).build(); return datastore.run(query); } // [END datastore_retrieve_entities]
Query.newEntityQueryBuilder() .setNamespace(NAMESPACE) .setKind(KIND1) .setFilter(PropertyFilter.hasAncestor(ROOT_KEY)) .build(); Query.newEntityQueryBuilder() .setNamespace(NAMESPACE) .setKind(KIND2) .setFilter(PropertyFilter.hasAncestor(ROOT_KEY)) .setOrderBy(OrderBy.asc("__key__")) .setNamespace(NAMESPACE) .setFilter(PropertyFilter.hasAncestor(ROOT_KEY)) .setKind("bla") .build(); results1 = getStronglyConsistentResults(scQuery1, query1);
.setKind("Person") .setFilter(PropertyFilter.eq("favorite_food", "pizza")) .build();
@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());
Query<Entity> query = Query.newEntityQueryBuilder() .setKind(KIND2) .setFilter(PropertyFilter.hasAncestor(KEY2)) .setNamespace(NAMESPACE)
@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()); } }
/** 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; }
/** Example of creating and running an entity query. */ // [TARGET newEntityQueryBuilder()] // [VARIABLE "my_kind"] public QueryResults<Entity> newEntityQuery(String kind) { // [START newEntityQuery] Query<Entity> query = Query.newEntityQueryBuilder().setKind(kind).build(); QueryResults<Entity> results = datastore.run(query); // Use results // [END newEntityQuery] return results; }