private void prepareQueryWhere(QueryBuilder<?> builder, Query q) throws FalsePredicateException { BaseCondition condition = builder.getCondition(); if (condition != null && condition.hasPreFilter()) { q.setFilter(createFilter(builder, condition)); } }
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); } }); }
@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(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 testQueryWithInequalityFilterAndFirstSortOnDifferentPropertyThrowsIllegalArgumentException() throws Exception { Query query = createQuery() .setFilter(new Query.FilterPredicate("foo", GREATER_THAN, 3)) .addSort("bar"); assertIAEWhenAccessingResult(service.prepare(query)); }
@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 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)))); }
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 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 testFilter() { int onePage = 5; String filterData = "ff"; Query query = new Query(kindName, rootKey); query.setFilter(new FilterPredicate("name", Query.FilterOperator.EQUAL, filterData)); // fetch first page Cursor cursor = checkPage(query, null, null, onePage, onePage, filterData, filterData); Cursor decodedCursor = Cursor.fromWebSafeString(cursor.toWebSafeString()); // fetch next page checkPage(query, decodedCursor, null, onePage, onePage, filterData, filterData); }
@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()); }
@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()); }
@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))))); }
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 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 @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)); }
@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 testFilterPredicate() { Query query = new Query(kindName, rootKey); query.setFilter(new FilterPredicate("intData", Query.FilterOperator.EQUAL, 20)); Entity e = service.prepare(query).asSingleEntity(); assertEquals("check query kind", kindName, query.getKind()); assertEquals("check query ancesor", rootKey, query.getAncestor()); Query.FilterPredicate fp = (Query.FilterPredicate) query.getFilter(); assertEquals("check FilterPredicate name", "intData", fp.getPropertyName()); assertEquals("check FilterPredicate operator", Query.FilterOperator.EQUAL, fp.getOperator()); assertEquals("check FilterPredicate value", e.getProperty("intData").toString(), fp.getValue().toString()); }
@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 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())); }