DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); Query gaeQuery = new Query(entityName); gaeQuery.setKeysOnly(); gaeQuery.addFilter("__key__", FilterOperator.EQUAL, key); PreparedQuery pq = datastore.prepare(gaeQuery); List<Entity> results = pq.asList(FetchOptions.Builder.withLimit(1)); Key elementKey = null; if (results.size() == 1) { elementKey = results.get(0).getKey(); }
@Override public List<String> listNamespaces() { DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); Query query = new Query("__namespace__").setKeysOnly(); PreparedQuery pq = ds.prepare(query); List<String> namespaces = new ArrayList<>(); for (Entity entity : pq.asIterable()) { namespaces.add(entity.getKey().getName()); } return namespaces; }
/** * Query on all of the keys for the data store ID. * * @param keysOnly whether to call {@link Query#setKeysOnly()} * @return iterable over the entities in the query result */ private Iterable<Entity> query(boolean keysOnly) { Query query = new Query(getId()); if (keysOnly) { query.setKeysOnly(); } return dataStoreService.prepare(query).asIterable(); } }
/** * Create a PreparedQuery that fetches keys only, relevant to our current state. */ private PreparedQuery prepareKeysOnly() { // Can't modify the query, we might need to use it again com.google.appengine.api.datastore.Query cloned = this.cloneRawQuery(this.actual); cloned.setKeysOnly(); return this.ofy.async().getAsyncDatastore().prepare(this.ofy.getTxn(), cloned); }
private void deleteAll(final String kind, final Key rootJobKey) { logger.info("Deleting all " + kind + " with rootJobKey=" + rootJobKey); final int chunkSize = 100; final FetchOptions fetchOptions = FetchOptions.Builder.withChunkSize(chunkSize); final PreparedQuery preparedQuery = dataStore.prepare(new Query(kind).setKeysOnly().setFilter( new FilterPredicate(ROOT_JOB_KEY_PROPERTY, EQUAL, rootJobKey))); tryFiveTimes(new Operation<Void>("delete") { @Override public Void call() { Iterator<Entity> iter = preparedQuery.asIterator(fetchOptions); while (iter.hasNext()) { ArrayList<Key> keys = new ArrayList<>(chunkSize); for (int i = 0; i < chunkSize && iter.hasNext(); i++) { keys.add(iter.next().getKey()); } logger.info("Deleting " + keys.size() + " " + kind + "s with rootJobKey=" + rootJobKey); dataStore.delete(null, keys); } return null; } }); }
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); }
/** * Applies the transactional operation (WAL: Write Ahead Log) to the * managing entity and unlocks it. */ @Override public void commit() { List<Key> deletes = new ArrayList<Key>(); deletes.add(Translation.toEntity(lock, Keys.create( Translation.toKind(entity.getClass()), Entities.keyValue(entity))).getKey()); Key transactionKey = KeyFactory.stringToKey(lock.transaction()); if (Keys.ancestor(transactionKey).equals( Keys.create(Translation.toKind(entity.getClass()), Entities.keyValue(entity)))) { deletes.add(transactionKey); for (Entity entity : datastore.query( new Query(transactionKey).setKeysOnly())) { deletes.add(entity.getKey()); } } Key parent = Keys.create(Translation.toKind(entity.getClass()), Entities.keyValue(entity)); apply(operation, entity, Translation.toEntity(lock, parent).getKey(), deletes); }
private PreparedQuery prepareQuery(QueryBuilder<?> builder, boolean keysOnly) throws FalsePredicateException { Query q = new Query(builder.getModel().getKind()); if (keysOnly) { q.setKeysOnly(); } prepareQueryAncestor(builder, q); prepareQueryWhere(builder, q); prepareQueryOrder(builder, q); return datastore().prepare(q); }
/** * Make a new Query object that is exactly like the old. Too bad Query isn't Cloneable. */ protected com.google.appengine.api.datastore.Query cloneRawQuery(com.google.appengine.api.datastore.Query orig) { com.google.appengine.api.datastore.Query copy = new com.google.appengine.api.datastore.Query(orig.getKind(), orig.getAncestor()); for (FilterPredicate filter: orig.getFilterPredicates()) copy.addFilter(filter.getPropertyName(), filter.getOperator(), filter.getValue()); for (SortPredicate sort: orig.getSortPredicates()) copy.addSort(sort.getPropertyName(), sort.getDirection()); // This should be impossible but who knows what might happen in the future if (orig.isKeysOnly()) copy.setKeysOnly(); return copy; }
@After public void tearDown() { List<Entity> entities = service.prepare(new Query(TEST_ENTITY_KIND).setKeysOnly()).asList(withDefaults()); for (Entity entity : entities) { service.delete(entity.getKey()); } }
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 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 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 testIndexListFromIterator() throws Exception { Entity parent = createTestEntityWithUniqueMethodNameKey("Person", "testKeysOnly"); Key key = parent.getKey(); Entity tom = createEntity("Person", key) .withProperty("name", "Tom") .withProperty("surname", "Foe") .store(); Query query = new Query("Person") .setAncestor(key) .setKeysOnly(); PreparedQuery preparedQuery = service.prepare(query); QueryResultIterator<Entity> iter = preparedQuery.asQueryResultIterator(); List<Index> indexes = iter.getIndexList(); if (indexes != null) { // TODO -- something useful System.out.println("indexes = " + indexes); } }
@Test public void testOrderOfReturnedResultsIsSameAsOrderOfElementsInInStatementWhenUsingKeysOnly() throws Exception { String methodName = "testOrderOfReturnedResultsIsSameAsOrderOfElementsInInStatementWhenUsingKeysOnly"; Entity parent = createTestEntityWithUniqueMethodNameKey("Product", methodName); Key key = parent.getKey(); Entity b = createEntity("Product", key) .withProperty("name", "b") .store(); Entity a = createEntity("Product", key) .withProperty("name", "a") .store(); Query query = new Query("Product") .setAncestor(key) .setKeysOnly() .setFilter(new Query.FilterPredicate("name", IN, Arrays.asList("a", "b"))); assertResultsInOrder(query, a, b); query = query.setFilter(new Query.FilterPredicate("name", IN, Arrays.asList("b", "a"))); assertResultsInOrder(query, b, a); }
@Test public void testIndexListFromList() throws Exception { Entity parent = createTestEntityWithUniqueMethodNameKey("Person", "testKeysOnly"); Key key = parent.getKey(); Entity joe = createEntity("Person", key) .withProperty("name", "Joe") .withProperty("surname", "Moe") .store(); Query query = new Query("Person") .setAncestor(key) .setKeysOnly(); PreparedQuery preparedQuery = service.prepare(query); QueryResultList<Entity> list = preparedQuery.asQueryResultList(FetchOptions.Builder.withDefaults()); List<Index> indexes = list.getIndexList(); if (indexes != null) { // TODO -- something useful System.out.println("indexes = " + indexes); } } }
@SuppressWarnings("LoopStatementThatDoesntLoop") @Test public void testKeysOnly() throws Exception { final Query query = new Query(kindName, rootKey); query.setKeysOnly(); for (Entity e : service.prepare(query).asIterable()) { Assert.assertNull(e.getProperty("intData")); break; } for (Entity e : service.prepare(query.clearKeysOnly()).asIterable()) { Assert.assertNotNull(e.getProperty("intData")); break; } }
/** * 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 testKeysOnly() throws Exception { Entity parent = createTestEntityWithUniqueMethodNameKey("Person", "testKeysOnly"); Key key = parent.getKey(); Entity john = createEntity("Person", key) .withProperty("name", "John") .withProperty("surname", "Doe") .store(); Query query = new Query("Person") .setAncestor(key) .setKeysOnly(); PreparedQuery preparedQuery = service.prepare(query); Entity entity = preparedQuery.asSingleEntity(); assertEquals(john.getKey(), entity.getKey()); assertNull(entity.getProperty("name")); assertNull(entity.getProperty("surname")); }
@Test public void testCursor() throws Exception { Entity parent = createTestEntityWithUniqueMethodNameKey("Person", "testKeysOnly"); Key key = parent.getKey(); Entity john = createEntity("Person", key) .withProperty("name", "John") .withProperty("surname", "Doe") .store(); Query query = new Query("Person") .setAncestor(key) .setKeysOnly(); PreparedQuery preparedQuery = service.prepare(query); QueryResultIterator<Entity> iter = preparedQuery.asQueryResultIterator(); Assert.assertNotNull(iter.next()); Cursor cursor = iter.getCursor(); iter = service.prepare(query).asQueryResultIterator(FetchOptions.Builder.withStartCursor(cursor)); Assert.assertFalse(iter.hasNext()); }