query.setFilter(new Query.FilterPredicate( name, Translation.toFilterOperator(comparableFilter.operator()), value)); } else if (filter instanceof InFilter<?>) { query.setFilter(new Query.FilterPredicate(name, FilterOperator.IN, values));
switch (fp.getOperator()) break; default: minOutput.remove(fp.getPropertyName()); // minus and-path filtered break; switch (fp.getOperator()) if (minOutput.contains(fp.getPropertyName()))
bld.append(filter.getPropertyName()); bld.append(filter.getOperator().name()); bld.append(filter.getValue());
if (!Strings.isNullOrEmpty(prefix)) { Key keyPrefix = makeKey(bucket, prefix); query.setFilter(new FilterPredicate(KEY_RESERVED_PROPERTY, GREATER_THAN_OR_EQUAL, keyPrefix)); prefixLength = prefix.length(); } else {
Filter filter = new FilterPredicate("timestamp", Query.FilterOperator.EQUAL, timestamp); q1.setFilter(filter); PreparedQuery p1 = datastore.prepare(q1);
NamespaceManager.set(namespaceDat[i]); Query q = new Query(kindTest); q.setFilter(new FilterPredicate("__key__", Query.FilterOperator.EQUAL, kList.get(i))); if (namespaceDat[i].equals("")) { assertEquals(service.prepare(q).asSingleEntity().getProperty("jobType"), q.setFilter(new FilterPredicate("__key__", Query.FilterOperator.EQUAL, kList.get(2)));
FilterPredicate greater = new FilterPredicate("name", FilterOperator.GREATER_THAN_OR_EQUAL, backupName); FilterPredicate less = new FilterPredicate("name", FilterOperator.LESS_THAN_OR_EQUAL, backupName + "Z"); List<Query.Filter> filters = new ArrayList<Query.Filter>(); filters.add(greater);
while (filterIter.hasNext()) { FilterPredicate pred = filterIter.next(); str.append(pred.getPropertyName() + pred.getOperator() + pred.getValue()); if (filterIter.hasNext()) { str.append(" AND ");
String cursor, final int limit) { Query query = new Query(JobRecord.DATA_STORE_KIND); Filter filter = classFilter == null || classFilter.isEmpty() ? new FilterPredicate( ROOT_JOB_DISPLAY_NAME, GREATER_THAN, null) : new FilterPredicate(ROOT_JOB_DISPLAY_NAME, EQUAL, classFilter); query.setFilter(filter); final PreparedQuery preparedQuery = dataStore.prepare(query);
private void validateJoinQuery(QueryData qd, DatastoreQuery query, String joinSortProp) { // all filters on the primary must be equality for (Query.FilterPredicate fp : qd.primaryDatastoreQuery.getFilterPredicates()) { if (fp.getOperator() != Query.FilterOperator.EQUAL) { throw query.new UnsupportedDatastoreFeatureException( "Filter on property '" + fp.getPropertyName() + "' uses operator '" + fp.getOperator() + "'. Joins are only supported when all filters are 'equals' filters."); } } // all filters on the join must be equality for (Query.FilterPredicate fp : qd.joinQuery.getFilterPredicates()) { if (fp.getOperator() != Query.FilterOperator.EQUAL) { throw query.new UnsupportedDatastoreFeatureException( "Filter on property '" + fp.getPropertyName() + "' uses operator '" + fp.getOperator() + "'. Joins are only supported when all filters are 'equals' filters."); } } List<Query.SortPredicate> primarySorts = qd.primaryDatastoreQuery.getSortPredicates(); // There must be 0 or 1 sort orders total. // If there is a sort order it must be on the join column in ascending order. // TODO(maxr): support sorting by join column in descending order if (primarySorts.size() > 1 || !qd.joinQuery.getSortPredicates().isEmpty() || (!primarySorts.isEmpty() && (!primarySorts.get(0).getPropertyName().equals(joinSortProp) || primarySorts.get(0).getDirection() != Query.SortDirection.ASCENDING))) { throw query.new UnsupportedDatastoreFeatureException( "Joins can only be sorted by the join column in " + "ascending order (in this case '" + joinSortProp +"')"); } }
@Test public void testProjectionOfCollectionPropertyWithFilterOnCollectionProperty() throws Exception { String methodName = "testProjectionOfCollectionPropertyWithFilterOnCollectionProperty"; Entity parent = createTestEntityWithUniqueMethodNameKey("Product", methodName); Key key = parent.getKey(); Entity e = createEntity("Product", key) .withProperty("name", Arrays.asList("aaa", "bbb")) .withProperty("price", Arrays.asList(10L, 20L)) .store(); Query query = new Query("Product") .setAncestor(key) .addProjection(new PropertyProjection("name", String.class)) .setFilter(new Query.FilterPredicate("price", GREATER_THAN, 0L)) .addSort("price") .addSort("name"); PreparedQuery preparedQuery = service.prepare(query); List<Entity> results = preparedQuery.asList(withDefaults()); assertEquals(4, results.size()); assertEquals(e.getKey(), results.get(0).getKey()); assertEquals(e.getKey(), results.get(1).getKey()); assertEquals(e.getKey(), results.get(2).getKey()); assertEquals(e.getKey(), results.get(3).getKey()); assertEquals("aaa", results.get(0).getProperty("name")); assertEquals("bbb", results.get(1).getProperty("name")); assertEquals("aaa", results.get(2).getProperty("name")); assertEquals("bbb", results.get(3).getProperty("name")); }
/** * Method to create a PreparedQuery, for the specified filter and ordering, to get the child objects of a parent. * @param parentKey Key of the parent * @param filterPredicates Filtering required * @param sortPredicates Ordering required * @param keysOnly Whether to just returns the keys of the children * @param kindName Name of the kind that we are querying * @return The PreparedQuery */ PreparedQuery prepareChildrenQuery(Key parentKey, Iterable<FilterPredicate> filterPredicates, Iterable<SortPredicate> sortPredicates, boolean keysOnly, String kindName) { Query q = new Query(kindName, parentKey); if (keysOnly) { q.setKeysOnly(); } NucleusLogger.PERSISTENCE.debug("Preparing to query for all children of " + parentKey + " of kind " + kindName); for (FilterPredicate fp : filterPredicates) { q.addFilter(fp.getPropertyName(), fp.getOperator(), fp.getValue()); NucleusLogger.PERSISTENCE.debug(" Added filter: " + fp.getPropertyName() + " " + fp.getOperator() + " " + fp.getValue()); } for (SortPredicate sp : sortPredicates) { q.addSort(sp.getPropertyName(), sp.getDirection()); NucleusLogger.PERSISTENCE.debug(" Added sort: " + sp.getPropertyName() + " " + sp.getDirection()); } DatastoreServiceConfig config = storeMgr.getDefaultDatastoreServiceConfigForReads(); DatastoreService ds = DatastoreServiceFactoryInternal.getDatastoreService(config); return ds.prepare(q); }
@Test public void testPropertyMetadata() { NamespaceManager.set(namespaceDat[2]); // sort by kind/property, kindDat[1] < kindDat[0] < kindDat[2] Query q = new Query("__property__").addSort(Entity.KEY_RESERVED_PROPERTY).setKeysOnly(); // filter out properties for kind "testing" Key key1 = Entities.createPropertyKey(kindDat[0], "urlData"); Key key2 = Entities.createPropertyKey(kindDat[2], "urlData"); q.setFilter(CompositeFilterOperator.and( new FilterPredicate(Entity.KEY_RESERVED_PROPERTY, FilterOperator.GREATER_THAN, key1), new FilterPredicate(Entity.KEY_RESERVED_PROPERTY, FilterOperator.LESS_THAN_OR_EQUAL, key2))); List<Entity> el = service.prepare(q).asList(fo); // un-indexed property, textData, will not be returned in __property__ queries. assertEquals(13, el.size()); for (int i = 0; i < el.size(); i++) { assertEquals(namespaceDat[2], el.get(i).getKey().getNamespace()); assertEquals(kindDat[2], el.get(i).getKey().getParent().getName()); if (i == 0) { assertEquals("adressData", el.get(0).getKey().getName()); } else if (i == el.size() - 1) { assertEquals("urlData", el.get(el.size() - 1).getKey().getName()); } } }
@Test public void testKindMetadata() { // check non empty namespace only for (int i = 1; i < namespaceDat.length; i++) { NamespaceManager.set(namespaceDat[i]); Query q = new Query("__kind__").addSort(Entity.KEY_RESERVED_PROPERTY); int count = 0; for (Entity e : service.prepare(q).asIterable()) { // do not count those stats entities for namespace. if (!e.getKey().getName().startsWith("__Stat_Ns_")) { count++; } } // For each namespace, only 3 user defined kinds. assertEquals(3, count); // check a specified namespace Key key1 = Entities.createKindKey("testing"); q.setFilter(new FilterPredicate(Entity.KEY_RESERVED_PROPERTY, FilterOperator.EQUAL, key1)); assertEquals(1, service.prepare(q).countEntities(fo)); Entity ke = service.prepare(q).asSingleEntity(); assertEquals("testing", ke.getKey().getName()); assertEquals(namespaceDat[i], ke.getKey().getNamespace()); assertEquals(namespaceDat[i], ke.getNamespace()); } }
@Test public void testEntityOnlyContainsProjectedProperties() throws Exception { String methodName = "testEntityOnlyContainsProjectedProperties"; Entity parent = createTestEntityWithUniqueMethodNameKey("Product", methodName); Key key = parent.getKey(); Entity b = createEntity("Product", key) .withProperty("name", "b") .withProperty("price", 1L) .store(); Entity a = createEntity("Product", key) .withProperty("name", "a") .withProperty("price", 2L) .store(); Query query = new Query("Product") .setAncestor(key) .addProjection(new PropertyProjection("price", Long.class)) .setFilter(new Query.FilterPredicate("name", IN, Arrays.asList("a", "b"))); Entity firstResult = service.prepare(query).asList(FetchOptions.Builder.withDefaults()).get(0); assertEquals(1, firstResult.getProperties().size()); assertEquals("price", firstResult.getProperties().keySet().iterator().next()); query = new Query("Product") .setKeysOnly() .setFilter(new Query.FilterPredicate("name", IN, Arrays.asList("a", "b"))); firstResult = service.prepare(query).asList(FetchOptions.Builder.withDefaults()).get(0); assertEquals(0, firstResult.getProperties().size()); }
@Test public void testUnindexedProperties() throws Exception { Entity entity = new Entity(UNINDEXED_ENTITY); entity.setUnindexedProperty("unindexedString", "unindexedString"); entity.setUnindexedProperty("unindexedList", new ArrayList<String>(Arrays.asList("listElement1", "listElement2", "listElement3"))); entity.setUnindexedProperty("unindexedText", new Text("unindexedText")); entity.setUnindexedProperty("unindexedBlob", new Blob("unindexedBlob".getBytes())); entity.setProperty("text", new Text("text")); entity.setProperty("blob", new Blob("blob".getBytes())); Key key = service.put(entity); sync(3000); // Not using ancestor queries, so pause before doing queries below. Entity entity2 = service.get(key); assertTrue(isUnindexed(getRawProperty(entity2, "unindexedString"))); assertTrue(isUnindexed(getRawProperty(entity2, "unindexedList"))); assertTrue(isUnindexed(getRawProperty(entity2, "unindexedText"))); assertTrue(isUnindexed(getRawProperty(entity2, "unindexedBlob"))); assertTrue(isUnindexed(getRawProperty(entity2, "text"))); assertTrue(isUnindexed(getRawProperty(entity2, "blob"))); assertNull(getResult(new Query(UNINDEXED_ENTITY).setFilter(new FilterPredicate("unindexedString", EQUAL, "unindexedString")))); assertNull(getResult(new Query(UNINDEXED_ENTITY).setFilter(new FilterPredicate("unindexedList", EQUAL, "listElement1")))); assertNull(getResult(new Query(UNINDEXED_ENTITY).setFilter(new FilterPredicate("unindexedText", EQUAL, "unindexedText")))); assertNull(getResult(new Query(UNINDEXED_ENTITY).setFilter(new FilterPredicate("text", EQUAL, "text")))); service.delete(key); }
@Ignore("According to the docs, ordering of query results is undefined when no sort order is specified. They are " + "currently ordered according to the index, but this may change in the future and so it shouldn't be tested by the TCK.") @Test public void testDefaultSortOrderIsDefinedByIndexDefinition() throws Exception { Key parentKey = createQueryBasicsTestParent("testDefaultSortOrderIsDefinedByIndexDefinition"); Entity aaa = createEntity("Product", parentKey) .withProperty("name", "aaa") .withProperty("price", 10) .store(); Entity ccc = createEntity("Product", parentKey) .withProperty("name", "ccc") .withProperty("price", 10) .store(); Entity bbb = createEntity("Product", parentKey) .withProperty("name", "bbb") .withProperty("price", 10) .store(); Query query = new Query("Product") .setAncestor(parentKey) .setFilter(and( new Query.FilterPredicate("name", GREATER_THAN_OR_EQUAL, "aaa"), new Query.FilterPredicate("price", EQUAL, 10) )); assertEquals(Arrays.asList(aaa, bbb, ccc), service.prepare(query).asList(withDefaults())); }
private List<Query.FilterPredicate> getFilterPredicates(int startIdx, int endIdx) { List<Query.FilterPredicate> filterPredicates = Utils.newArrayList(); if (indexedList) { String indexProperty = getIndexPropertyName(); if (startIdx >= 0 && endIdx == startIdx) { // Particular index required so add restriction Query.FilterPredicate filterPred = new Query.FilterPredicate(indexProperty, Query.FilterOperator.EQUAL, startIdx); filterPredicates.add(filterPred); } else if (startIdx != -1 || endIdx != -1) { // Add restrictions on start/end indices as required if (startIdx >= 0) { Query.FilterPredicate filterPred = new Query.FilterPredicate(indexProperty, Query.FilterOperator.GREATER_THAN_OR_EQUAL, startIdx); filterPredicates.add(filterPred); } if (endIdx >= 0) { Query.FilterPredicate filterPred = new Query.FilterPredicate(indexProperty, Query.FilterOperator.LESS_THAN, endIdx); filterPredicates.add(filterPred); } } } return filterPredicates; }
private static <T extends TempData> List<T> getAllTempData(Class<T> type, boolean unreadOnly) { try { DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); String kind = getKind(type); Query query = new Query(kind); if (unreadOnly) { query.setFilter(new Query.FilterPredicate(TEMP_DATA_READ_PROPERTY, Query.FilterOperator.EQUAL, false)); } else { query.addSort("timestamp", Query.SortDirection.ASCENDING); } PreparedQuery pq = ds.prepare(query); Iterator<Entity> iter = pq.asIterator(); List<T> result = new ArrayList<>(); while (iter.hasNext()) { Entity entity = iter.next(); T data = readTempData(type, entity, ds); result.add(data); } return result; } catch (Exception e) { throw new IllegalStateException(e); } }
@Test public void testWithIneqiAndFilter() { Query query = new Query(kindName, rootKey); query.setFilter(new FilterPredicate("loc", Query.FilterOperator.EQUAL, "ae")); Key key = service.prepare(query).asSingleEntity().getKey(); query = new Query(kindName, rootKey); query.setFilter(new FilterPredicate("__key__", Query.FilterOperator.LESS_THAN, key)); query.setFilter(new FilterPredicate("loc", Query.FilterOperator.EQUAL, "ac")); query.addSort("__key__"); List<Entity> ascRecs = service.prepare(query).asList(withLimit(5)); query = new Query(kindName, rootKey); query.setFilter(new FilterPredicate("__key__", Query.FilterOperator.LESS_THAN, key)); query.setFilter(new FilterPredicate("loc", Query.FilterOperator.EQUAL, "ac")); query.addSort("__key__", Query.SortDirection.DESCENDING); List<Entity> descRecs = service.prepare(query).asList(withLimit(5)); int size = ascRecs.size(); for (int i = 0; i < size; i++) { assertEquals(ascRecs.get(i).getProperty("pop").toString(), descRecs.get(size - i - 1).getProperty("pop").toString()); } }