Query query = new Query("__BlobInfo__"); query.addFilter("filename", FilterOperator.EQUAL, filename); DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); PreparedQuery pq = datastore.prepare(query); List<Entity> entList = pq.asList(FetchOptions.Builder.withLimit(1)); String name = entList.get(0).getKey().getName();
@Override public PreparedQuery prepare(Transaction txn, Query query) { return this.ds.prepare(txn, query); }
DatastoreService datastore = DatastoreServiceFactory .getDatastoreService(); List<Foo> results = new ArrayList<Foo>(); Query query = new Query("Foo", KeyFactory.stringToKey("")); List<Entity> entities = datastore.prepare(query).asList( FetchOptions.Builder.withDefaults()); for (Entity entity : entities) { results.add(new Foo(entity)); }
Query query = new Query(Entities.KIND_METADATA_KIND); DatastoreService datastoreService = DatastoreServiceFactory.getDatastoreService(); Iterable<Entity> entityIterable = datastoreService.prepare(query).asIterable(); for(Entity entity : entityIterable) { System.out.println("Entity kind: " + entity.getKey().getName()); }
DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); Query q = new Query(entityKind); PreparedQuery pq = ds.prepare(q); for (Entity e : pq.asIterable()) { String longtext = ((Text)e.getProperty("somelongdescription")).getValue();}
public PreparedQuery prepare(Transaction transaction, Query query) { try { return inner.prepare(transaction, query); } catch (IllegalArgumentException e) { throw wrapIllegalArgumentException(e); } catch (DatastoreFailureException e) { throw wrapDatastoreFailureException(e); } }
DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); Query query = new Query("__Stat_Kind__"); Query.Filter eqf = new Query.FilterPredicate("kind_name", Query.FilterOperator.EQUAL, "MY_ENTITY_KIND"); query.setFilter(eqf); Entity entityStat = ds.prepare(query).asSingleEntity(); Long totalEntities = (Long) entityStat.getProperty("count");
Query query = new Query("SomeKind"); query.setFilter(new FilterPredicate("name", FilterOperator.EQUAL, "john")); query.setKeysOnly(); DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); List<Entity> entities = ds.prepare(query).asList(FetchOptions.Builder.withLimit(1)); if(entities.size() == 1) { //Exists! }
DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); Query q = new Query("Entity"); PreparedQuery pq = datastore.prepare(q); for (com.google.appengine.api.datastore.Entity result : pq.asIterable()) { String content = (String) result.getProperty("content"); if (content != null) { result.setProperty("content", new com.google.appengine.api.datastore.Text(content)); datastore.put(result); } }
DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); Query q = new Query("Items"); PreparedQuery pq = ds.prepare(q); for (Entity result : pq.asIterable()) { if (longDescription isinstanceof Text) Text longDescription = (Text)result.getProperty("longDescription"); else log.severe("Unexpected datatype: longDescription is a " + result.getProperty("longDescription").getClass().toString()); }
DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); PreparedQuery global = datastore.prepare(new Query("__Stat_Kind__")); for( Entity globalStat : global.asIterable() ) { Long totalBytes = (Long) globalStat.getProperty("bytes"); Long totalEntities = (Long) globalStat.getProperty("count"); String kindName = (String) globalStat.getProperty("kind_name"); resp.getWriter().println("[" + kindName + "] has " + totalEntities + " entities and takes up " + totalBytes + "bytes<br/>"); }
public List<Entity> queryAll(final String kind, final Key rootJobKey) { Query query = new Query(kind); query.setFilter(new FilterPredicate(ROOT_JOB_KEY_PROPERTY, EQUAL, rootJobKey)); final PreparedQuery preparedQuery = dataStore.prepare(query); final FetchOptions options = FetchOptions.Builder.withChunkSize(500); return tryFiveTimes(new Operation<List<Entity>>("queryFullPipeline") { @Override public List<Entity> call() { return preparedQuery.asList(options); } }); }
private void checkCount(String statsKind) { FetchOptions fo = FetchOptions.Builder.withDefaults(); Query query = new Query(statsKind); assertTrue(service.prepare(query).countEntities(fo) > 0); for (Entity readRec : service.prepare(query).asIterable()) { assertTrue((Long) readRec.getProperty("count") > 0); } } }
@Test public void testSortPredicates() { Query query = new Query(kindName, rootKey); query.addSort("intData", Query.SortDirection.DESCENDING); List<Entity> es = service.prepare(query).asList(fo); assertEquals((long) 40, es.get(0).getProperty("intData")); List<Query.SortPredicate> qsp = query.getSortPredicates(); assertEquals("check SortPredicate name", "intData", qsp.get(0).getPropertyName()); assertEquals("check SortPredicate direction", Query.SortDirection.DESCENDING, qsp.get(0).getDirection()); }
@Test public void queriesDontReturnDeletedEntities() throws Exception { String methodName = "queriesDontReturnDeletedEntities"; Entity entity = createTestEntityWithUniqueMethodNameKey(SMOKE_TEST_ENTITY, methodName); Key key = entity.getKey(); service.put(entity); service.delete(key); List<Entity> entities = service.prepare(new Query(SMOKE_TEST_ENTITY).setAncestor(key)) .asList(FetchOptions.Builder.withDefaults()); assertEquals(0, entities.size()); }
@Test public void testDistinctSort() { Query query = new Query(kindName, rootKey); query.addProjection(new PropertyProjection("stringData", String.class)); query.addProjection(new PropertyProjection("floatData", Float.class)); query.addSort("stringData", Query.SortDirection.DESCENDING); query.setDistinct(true); assertEquals(7, service.prepare(query).countEntities(fo)); assertTrue(query.getDistinct()); query.addSort("floatData", Query.SortDirection.DESCENDING); assertEquals(7, service.prepare(query).countEntities(fo)); }
@Test public void testIntegerPropertySortingIsNotLexicographic() throws Exception { String methodName = "testIntegerPropertySortingIsNotLexicographic"; Entity parent = createTestEntityWithUniqueMethodNameKey(QUERY_SORTING_ENTITY, methodName); Key key = parent.getKey(); Entity ten = storeTestEntityWithSingleProperty(key, 10); Entity five = storeTestEntityWithSingleProperty(key, 5); Query query = createQuery().setAncestor(key).addSort(SINGLE_PROPERTY_NAME, ASCENDING); List<Entity> results = service.prepare(query).asList(withDefaults()); assertTrue(results.indexOf(five) < results.indexOf(ten)); // if sorting were lexicographic, "10" would come before "5" service.delete(ten.getKey(), five.getKey()); }
@Test public void testFilterOnMultiValuedProperty() throws Exception { Key parentKey = createQueryBasicsTestParent("testFilterOnMultiValuedProperty"); createEntity("Entry", parentKey) .withProperty("letters", Arrays.asList("a", "b", "c")) .store(); Query query = new Query("Entry") .setAncestor(parentKey) .setFilter(new Query.FilterPredicate("letters", EQUAL, "a")); assertNotNull(service.prepare(query).asSingleEntity()); }
public void purgeTestRunRecords() { DatastoreService datastoreService = DatastoreServiceFactory. getDatastoreService(); FilterPredicate testRunFilter = new FilterPredicate(TEST_RUN_ID, FilterOperator.EQUAL, testRunId); Query query = new Query(entityName).setFilter(testRunFilter).setKeysOnly(); for (Entity readRec : datastoreService.prepare(query).asIterable()) { datastoreService.delete(readRec.getKey()); } }
@Test public void testNullPropertyValue() throws Exception { Key parentKey = createQueryBasicsTestParent("testNullPropertyValue"); createEntity("Entry", parentKey) .withProperty("user", null) .store(); Entity entity = service.prepare(new Query("Entry") .setAncestor(parentKey)).asSingleEntity(); assertNull(entity.getProperty("user")); }