@Test public void testQueryFilter() { Query query = new Query(kindName, rootKey); query.addProjection(new PropertyProjection("stringData", String.class)); query.setFilter(new FilterPredicate("intData", FilterOperator.NOT_EQUAL, 50)); query.addSort("intData"); List<Entity> results = service.prepare(query).asList(fetchOption); assertEquals(count - 1, results.size()); for (Entity e : results) { assertTrue(e.getProperty("stringData").toString().contains("5") == false); } }
@Test public void testQueryOnSomePropertyWithKeyInDifferentNamespace() { NamespaceManager.set("one"); Key keyInNamespaceOne = KeyFactory.createKey("kind", 1); NamespaceManager.set("two"); Query query = new Query("kind").setFilter(new Query.FilterPredicate("someProperty", EQUAL, keyInNamespaceOne)); PreparedQuery preparedQuery = service.prepare(query); preparedQuery.asSingleEntity(); // should not throw IllegalArgumentException as in previous test preparedQuery.asIterator().hasNext(); // should not throw IllegalArgumentException as in previous test preparedQuery.asList(withDefaults()).size(); // should not throw IllegalArgumentException as in previous test } }
@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()); }
private Entity getParent() { Query query = new Query(PARENTKIND); query.setFilter(new FilterPredicate("name", Query.FilterOperator.EQUAL, "argonaut")); Entity parent = service.prepare(query).asSingleEntity(); return parent; } }
@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 Filter createSimpleFilter(QueryBuilder<?> builder, SimpleCondition condition) throws FalsePredicateException { String field = condition.getField(); Class<?> clazz = builder.getModel().getClazz(); Object whereValue = condition.getWhereValue(); WhereOperator whereOperator = condition.getWhereOperator(); String actualFieldName = getActualFieldName(field, clazz); Object actualValue = getActualFieldValue(field, clazz, whereValue); if (whereOperator == WhereOperator.IN && listSize(whereValue) == 0) { throw new FalsePredicateException(); } return new FilterPredicate(actualFieldName, getFilterOperator(whereOperator), actualValue); }
@Test public void testQueryWithInequalityFilterOnKeyPropertyAndEqualityFilterOnOtherPropertyDoesNotRequireConfiguredIndex() throws Exception { executeQuery( new Query("Unindexed") .setFilter( and(new Query.FilterPredicate(Entity.KEY_RESERVED_PROPERTY, GREATER_THAN, KeyFactory.createKey("Unindexed", 1)), new Query.FilterPredicate("otherProperty", EQUAL, "b")))); }
@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 testQueryWithInequalityFilterAndFirstSortOnSamePropertyIsAllowed() throws Exception { Query query = createQuery() .setFilter(new Query.FilterPredicate("foo", GREATER_THAN, 3)) .addSort("foo") .addSort("bar"); service.prepare(query).asList(withDefaults()); }
@Test public void testQueryWithInequalityFilterAndFirstSortOnDifferentPropertyThrowsIllegalArgumentException() throws Exception { Query query = createQuery() .setFilter(new Query.FilterPredicate("foo", GREATER_THAN, 3)) .addSort("bar"); assertIAEWhenAccessingResult(service.prepare(query)); }
@Test @InSequence(4) public void testStep4BigAsIterator() { Query q = new Query(kindName, rootKey); q.setFilter(new FilterPredicate("count", FilterOperator.LESS_THAN, bigCount)); Iterator<Entity> eData = service.prepare(q).asIterator(fo); assertEquals(bigCount, getSize(eData)); }
public Entity getMarker(String marker) { DatastoreService service = DatastoreServiceFactory.getDatastoreService(); FilterPredicate testRunFilter = new FilterPredicate(TEST_RUN_ID, FilterOperator.EQUAL, testRunId); FilterPredicate markerFilter = new FilterPredicate(MARKER, FilterOperator.EQUAL, marker); CompositeFilter filter = CompositeFilterOperator.and(testRunFilter, markerFilter); Query query = new Query(entityName).setFilter(filter); return service.prepare(query).asSingleEntity(); }
@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 testQueryUsingOnlyEqualityFiltersDoesNotRequireConfiguredIndex() throws Exception { executeQuery(new Query("Unindexed") .setFilter(new Query.FilterPredicate("someProperty", EQUAL, "foo"))); executeQuery(new Query("Unindexed") .setFilter( and(new Query.FilterPredicate("someProperty", EQUAL, "foo"), new Query.FilterPredicate("otherProperty", EQUAL, "bar")))); }
@Test public void testFilterInNull() throws Exception { Key parentKey = createQueryBasicsTestParent("testFilterInNull"); createEntity("Entry", parentKey) .withProperty("user", null) .store(); Query query = new Query("Entry") .setAncestor(parentKey) .setFilter(new Query.FilterPredicate("user", IN, Arrays.asList(null, "foo"))); assertNotNull(service.prepare(query).asSingleEntity()); }
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); } }); }
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(expected = DatastoreNeedIndexException.class) public void testQueryWithInequalityFilterAndSortOnAnotherPropertyRequiresConfiguredIndex() throws Exception { executeQuery( new Query("Unindexed") .setFilter(new Query.FilterPredicate("someProperty", GREATER_THAN, "foo")) .addSort("someProperty") .addSort("otherProperty")); }
@Test public void testQueryWithAncestorAndInequalityFilterOnKeyPropertyDoesNotRequireConfiguredIndex() throws Exception { executeQuery( new Query("Unindexed") .setAncestor(KeyFactory.createKey("Ancestor", 1)) .setFilter(new Query.FilterPredicate(Entity.KEY_RESERVED_PROPERTY, GREATER_THAN, KeyFactory.createKey("Unindexed", 1)))); }
@Test public void testQueryWithEqalityAndInequalityFilterOnKeyPropertyDoesNotRequireConfiguredIndex() throws Exception { executeQuery( new Query("Unindexed") .setFilter( and(new Query.FilterPredicate(Entity.KEY_RESERVED_PROPERTY, GREATER_THAN, KeyFactory.createKey("Unindexed", 1)), new Query.FilterPredicate(Entity.KEY_RESERVED_PROPERTY, EQUAL, KeyFactory.createKey("Unindexed", 2))))); }