public static List<String> findAllEntityKinds() throws LeanException { Query q = new Query(Query.KIND_METADATA_KIND); DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); PreparedQuery pq = datastore.prepare(q); List<Entity> list = pq.asList(FetchOptions.Builder.withDefaults()); List<String> result = new ArrayList<String>(); for (Entity entity : list) { if (!entity.getKey().getName().startsWith("_")) result.add(entity.getKey().getName()); } return result; }
public static List<Entity> getPrivateEntities(String kind) throws LeanException { if (!pattern.matcher(kind).matches()) { throw new LeanException(LeanException.Error.IllegalEntityName); } LeanAccount account = AuthService.getCurrentAccount(); // this should not happen, but we check anyway if (account == null) throw new LeanException(LeanException.Error.NotAuthorized); Query query = new Query(kind); query.addFilter("_account", Query.FilterOperator.EQUAL, account.id); PreparedQuery pq = datastore.prepare(query); return pq.asList(FetchOptions.Builder.withDefaults()); }
@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); } }
@Before public void createData() throws InterruptedException { Query q = new Query(kindName, rootKey); if (service.prepare(q).countEntities(FetchOptions.Builder.withDefaults()) == 0) { Entity newRec; String[] locDat = {"ac", "ab", "ae", "aa", "ac"}; List<Entity> elist = new ArrayList<>(); int[] popDat = {8008278, 279557, 1222, 0, 12345}; for (int i = 0; i < locDat.length; i++) { newRec = new Entity(kindName, rootKey); newRec.setProperty("loc", locDat[i]); newRec.setProperty("pop", popDat[i]); elist.add(newRec); } service.put(elist); sync(waitTime); } }
@Test public void testEntityKeyInequalityFilter() { Entity parentEntity = createTestEntityWithUniqueMethodNameKey(TEST_ENTITY_KIND, "testFilterByInequalityFilter"); Key parentKey = parentEntity.getKey(); Entity entity1 = new Entity("foo", parentKey); service.put(entity1); Entity entity2 = new Entity("foo", parentKey); service.put(entity2); Query query = new Query("foo") .setAncestor(parentKey) .setFilter(new Query.FilterPredicate(Entity.KEY_RESERVED_PROPERTY, GREATER_THAN, entity1.getKey())); List<Entity> list = service.prepare(query).asList(FetchOptions.Builder.withDefaults()); assertEquals(1, list.size()); assertEquals(entity2.getKey(), list.get(0).getKey()); }
@Test public void testFilterByEntityKey() { Entity parentEntity = createTestEntityWithUniqueMethodNameKey(TEST_ENTITY_KIND, "testFilterByEntityKey"); Key parentKey = parentEntity.getKey(); Key fooKey = KeyFactory.createKey(parentKey, "foo", 1); Entity fooEntity = new Entity(fooKey); service.put(fooEntity); Query query = new Query("foo") .setAncestor(parentKey) .setFilter(new Query.FilterPredicate(Entity.KEY_RESERVED_PROPERTY, EQUAL, fooKey)); PreparedQuery preparedQuery = service.prepare(query); List<Entity> results = preparedQuery.asList(FetchOptions.Builder.withDefaults()); assertEquals(1, results.size()); assertEquals(fooEntity, results.get(0)); }
protected FetchOptions withDefaults() { return FetchOptions.Builder.withDefaults(); }
@Test public void testReverse() throws Exception { final Query query = new Query(kindName, rootKey); query.addSort(Entity.KEY_RESERVED_PROPERTY); query.addSort("intData"); List<Entity> list1 = service.prepare(query).asList(FetchOptions.Builder.withDefaults()); List<Entity> list2 = service.prepare(query.reverse()).asList(FetchOptions.Builder.withDefaults()); int size = list1.size(); Assert.assertEquals(size, list2.size()); for (int i = 0; i < size; i++) { Assert.assertEquals(list1.get(i), list2.get(size - i - 1)); } }
@Test public void testDiffNamespace() { NamespaceManager.set(namespaceDat[1]); Query q = new Query(kindName); q.setFilter(new FilterPredicate("jobType", Query.FilterOperator.EQUAL, stringDat[2] + 1)); int ttl = service.prepare(q).countEntities(FetchOptions.Builder.withDefaults()); assertEquals(0, ttl); }
@Test @InSequence(9) public void testStep9BigFilterIn() { int filterNum = 500; Query q = new Query(kindName, rootKey); q.setFilter(new FilterPredicate("count", FilterOperator.IN, getFilterIn(filterNum))); FetchOptions fo = FetchOptions.Builder.withDefaults(); int ttl = service.prepare(q).countEntities(fo); assertEquals(filterNum, ttl); }
private QueryResultList<Entity> getNamespaces() { FetchOptions fetchOptions = FetchOptions.Builder.withDefaults(); fetchOptions.limit(BATCH_SIZE); if (cursor != null) { fetchOptions.startCursor(Cursor.fromWebSafeString(cursor)); } Query q = new Query(NAMESPACE_METADATA_KIND); q.setKeysOnly(); return datastore.prepare(q).asQueryResultList(fetchOptions); }
@Test public void testKindless() { Query query = new Query(PARENTKIND); query.setFilter(new FilterPredicate("name", Query.FilterOperator.EQUAL, "argonaut")); Entity parent = service.prepare(query).asSingleEntity(); query = new Query(parent.getKey()); assertEquals(3, service.prepare(query) .countEntities(FetchOptions.Builder.withDefaults())); query = new Query().setAncestor(parent.getKey()); assertEquals(3, service.prepare(query) .countEntities(FetchOptions.Builder.withDefaults())); }
@Test public void testAncestor() { Key pKey = getParent().getKey(); Query query = new Query(CHILDKIND, pKey); assertEquals(2, service.prepare(query) .countEntities(FetchOptions.Builder.withDefaults())); for (Entity cRec : service.prepare(query).asIterable()) { assertEquals(pKey, cRec.getParent()); } }
public static void deleteTempData(Class<? extends TempData> type) { // check if in-container if (isInContainer() == false) { return; } String kind = getKind(type); DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); final List<Entity> list = ds.prepare(new Query(kind)).asList(FetchOptions.Builder.withDefaults()); for (Entity e : list) { deleteTempDataInTx(ds, e, type); } }
@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()); } }
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 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()); }
protected List<Entity> doQuery(String kind, String pName, Class<?> type, boolean indexed) { FetchOptions fo = FetchOptions.Builder.withDefaults(); Query query = new Query(kind, rootKey); if (indexed) { query.addProjection(new PropertyProjection(pName, type)); query.addSort(pName); } return service.prepare(query).asList(fo); }
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 FetchOptions configureFetchOptions(QueryBuilder<?> builder) { FetchOptions fetchOptions = FetchOptions.Builder.withDefaults(); if (builder.getLimit() != null) { fetchOptions.limit(builder.getLimit()); } if (builder.getCursor() != null) { fetchOptions.startCursor(Cursor.fromWebSafeString(builder.getCursor())); } return fetchOptions; }