Refine search
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();
private List<Entity> readMultipleGroup(GroupParentKeys keys) { List<Entity> es = new ArrayList<>(); es.clear(); Query q = new Query(kindName).setAncestor(keys.firstParent); es.add(service.prepare(q).asSingleEntity()); q = new Query(otherKind).setAncestor(keys.secondParent); es.add(service.prepare(q).asSingleEntity()); return es; }
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(); 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); } }
@Override public void clearData(String kind) { List<Key> elist = new ArrayList<>(); Query query = new Query(kind); for (Entity readRec : service.prepare(query).asIterable()) { elist.add(readRec.getKey()); } service.delete(elist); sync(sleepTime); } }
Query q = new Query("AllowedUser"); q.setFilter(new FilterPredicate("JID", Query.FilterOperator.EQUAL, "[[ user JID to check ]]"); PreparedQuery pq = datastore.prepare(q); if (pq.countEntities(FetchOptions.Builder.withLimit(1)) > 0) { // user is allowed } else { // user is not allowed }
@Test public void testAncestorKey() { Key pKey = getParent().getKey(); Query query = new Query(CHILDKIND, pKey); query.addSort("__key__"); assertEquals(2, service.prepare(query) .countEntities(FetchOptions.Builder.withDefaults())); for (Entity cRec : service.prepare(query).asIterable()) { assertEquals(pKey, cRec.getParent()); } }
@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 testIndexListFromIterator() throws Exception { Entity parent = createTestEntityWithUniqueMethodNameKey("Person", "testKeysOnly"); Key key = parent.getKey(); Entity tom = createEntity("Person", key) .withProperty("name", "Tom") .withProperty("surname", "Foe") .store(); Query query = new Query("Person") .setAncestor(key) .setKeysOnly(); PreparedQuery preparedQuery = service.prepare(query); QueryResultIterator<Entity> iter = preparedQuery.asQueryResultIterator(); List<Index> indexes = iter.getIndexList(); if (indexes != null) { // TODO -- something useful System.out.println("indexes = " + indexes); } }
Query query = new Query("Issue"); List<String> list = Arrays.asList("NEW", "OPEN", "ACCEPTED"); query.addFilter("status", FilterOperator.IN, list); DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); PreparedQuery preparedQuery = datastore.prepare(query); for (Entity entity : preparedQuery.asIterable()) { // should iterate over 'NEW', 'OPEN' and 'ACCEPTED' issues }
@Before public void createData() throws InterruptedException, ParseException { Date[] testDatas = {dfDateTime.parse("2001,1,1,23,59,59"), dfDateTime.parse("2005,5,5,13,19,19"), dfDateTime.parse("2008,8,8,3,9,9")}; Query q = new Query(kindName, rootKey); if (service.prepare(q).countEntities(FetchOptions.Builder.withDefaults()) == 0) { List<Entity> elist = new ArrayList<Entity>(); for (Date data : testDatas) { Entity newRec = new Entity(kindName, rootKey); newRec.setProperty(propertyName, data); elist.add(newRec); } service.put(elist); sync(waitTime); } }
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()); } }
// Construct then prepare your query List<Entity> get5TallestPeople() { DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); Query q = new Query("Person"); q.addSort("height", SortDirection.DESCENDING); PreparedQuery pq = ds.prepare(q); return pq.asList(FetchOptions.Builder.withLimit(5)); }
@Test public void testQueryWithoutAnyConstraints() throws Exception { Key parentKey = createQueryBasicsTestParent("testQueryWithoutAnyConstraints"); Entity person = new Entity("Person", parentKey); service.put(person); Entity address = new Entity("Address", parentKey); service.put(address); PreparedQuery preparedQuery = service.prepare(new Query().setAncestor(parentKey)); assertTrue(preparedQuery.countEntities(withDefaults()) >= 2); List<Entity> results = preparedQuery.asList(withDefaults()); assertTrue(results.containsAll(Arrays.asList(person, address))); }
@Test public void testSetFilterInt() { Query query = new Query(kindName, rootKey); List<Filter> filterList = new ArrayList<>(); filterList.add(Query.FilterOperator.EQUAL.of("intData", 20)); filterList.add(Query.FilterOperator.GREATER_THAN.of("intData", 0)); Filter filter = Query.CompositeFilterOperator.and(filterList); query.setFilter(filter); assertEquals(1, service.prepare(query).countEntities(fo)); }
DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); Query query = new Query("table1"); query.addFilter("id", FilterOperator.EQUAL, "12345"); PreparedQuery pq = datastore.prepare(query); Entity customer = pq.asSingleEntity();
Query q = new Query("Person"); PreparedQuery pq = datastore.prepare(q); int pageSize = 15; QueryResultList<Entity> results = pq.asQueryResultList(fetchOptions); for (Entity entity : results) { resp.getWriter().println("<li>" + entity.getProperty("name") + "</li>");
protected Object[] getResult(Query query, String pName) { int count = service.prepare(query).countEntities(FetchOptions.Builder.withDefaults()); Object result[] = new Object[count]; int pt = 0; for (Entity readRec : service.prepare(query).asIterable()) { result[pt++] = readRec.getProperty(pName); } return result; }
private QueryResultList<Entity> executeQuery(FetchOptions fetchOptions) { Query query = new Query("Foo").addSort("bar"); return service.prepare(query).asQueryResultList(fetchOptions); }