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 }
@Override public int count() { return this.prepare().countEntities(this.fetchOptions()); }
@Test public void testCountEntitiesWithOptions() throws Exception { assertEquals("number of results", 1, preparedQuery.countEntities(withDefaults())); }
@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)); }
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; }
protected void assertSingleResult(Entity expectedEntity, Query query) { PreparedQuery preparedQuery = service.prepare(query); assertEquals("number of results", 1, preparedQuery.countEntities(withDefaults())); Entity entityFromQuery = preparedQuery.asSingleEntity(); assertEquals(expectedEntity, entityFromQuery); }
@Test @InSequence(1) public void testStep1GetCount() { Query q = new Query(kindName, rootKey); assertEquals(bigCount, service.prepare(q).countEntities(fo)); }
@Test public void testSetFilterRating() { Query query = new Query(kindName, rootKey); List<Filter> filterList = new ArrayList<>(); filterList.add(Query.FilterOperator.LESS_THAN.of("ratingData", new Rating(30))); filterList.add(Query.FilterOperator.GREATER_THAN.of("ratingData", new Rating(0))); Filter filter1 = Query.CompositeFilterOperator.or(filterList); Filter filter2 = Query.FilterOperator.EQUAL.of("ratingData", new Rating(20)); query.setFilter(Query.CompositeFilterOperator.and(filter1, filter2)); assertEquals(1, service.prepare(query).countEntities(fo)); }
@Test @InSequence(12) public void testStep12BigDelete() throws InterruptedException { clearData(kindName); Query q = new Query(kindName, rootKey); int ttl = service.prepare(q).countEntities(fo); assertEquals(0, ttl); } }
@Test public void testDataDelete() throws Exception { Entity parent = createTestEntityWithUniqueMethodNameKey(ASYNC_ENTITY, "testDataDelete"); Key key = parent.getKey(); Entity newRec = new Entity(ASYNC_ENTITY); newRec.setProperty("count", 0); newRec.setProperty("timestamp", new Date()); Key ekey = service.put(newRec); Future<Void> future = asyncService.delete(ekey); future.get(); assertTaskIsDoneAndNotCancelled(future); assertEquals(0, service.prepare(simpleQuery(key)).countEntities(withDefaults())); }
@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 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))); }
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 testSetFilterString() { Query query = new Query(kindName, rootKey); Filter filter = Query.CompositeFilterOperator.or( Query.FilterOperator.GREATER_THAN.of("stringData", "string data2"), Query.FilterOperator.LESS_THAN.of("stringData", "string data1")); query.setFilter(filter); assertEquals(1, service.prepare(query).countEntities(fo)); }
@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 testDistinctNum() { Query query = new Query(kindName, rootKey); query.addProjection(new PropertyProjection("floatData", Float.class)); query.setDistinct(true); assertEquals(4, service.prepare(query).countEntities(fo)); assertTrue(query.getDistinct()); query = new Query(kindName, rootKey); query.addProjection(new PropertyProjection("floatData", Float.class)); query.setDistinct(false); assertEquals(count, service.prepare(query).countEntities(fo)); assertFalse(query.getDistinct()); }
@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()); } }
@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 testDistinctFilter() { Query query = new Query(kindName, rootKey); query.addProjection(new PropertyProjection("stringData", String.class)); query.addProjection(new PropertyProjection("floatData", Float.class)); query.setFilter(new FilterPredicate("stringData", Query.FilterOperator.NOT_EQUAL, "string1")); query.addSort("stringData", Query.SortDirection.DESCENDING); query.setDistinct(true); assertEquals(5, service.prepare(query).countEntities(fo)); assertTrue(query.getDistinct()); }
@Test public void testDistinctStr() { Query query = new Query(kindName, rootKey); query.addProjection(new PropertyProjection("stringData", String.class)); query.setDistinct(true); assertTrue(query.getDistinct()); // distinct false query = new Query(kindName, rootKey); query.addProjection(new PropertyProjection("stringData", String.class)); query.setDistinct(false); assertEquals(count, service.prepare(query).countEntities(fo)); assertFalse(query.getDistinct()); }