Query query = new Query("__BlobInfo__"); query.addFilter("filename", FilterOperator.EQUAL, filename); DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); PreparedQuery pq = datastore.prepare(query); List<Entity> entList = pq.asList(FetchOptions.Builder.withLimit(1)); String name = entList.get(0).getKey().getName();
@Override public List<Entity> call() { return preparedQuery.asList(options); } });
public static boolean kindExists (String kind) { Query q = new Query(kind).setKeysOnly(); PreparedQuery pq = DatastoreServiceFactory.getDatastoreService().prepare(q); return (CollectionUtils.isNotEmpty(pq.asList(FetchOptions.Builder.withLimit(1)))); }
public static List<Entity> listEntities(String kind) { logger.log(Level.INFO, "Search entities based on search criteria"); Query q = new Query(kind); PreparedQuery pq = datastore.prepare(q); FetchOptions fetchOptions = FetchOptions.Builder.withDefaults(); return pq.asList(fetchOptions); }
/** * Executes the specified query with the specified fetch options. * * @param query The query to be executed. * @param options The fetch options which the specified query is executed * with. * @return The query result as {@code List} view. */ public List<Entity> query(Query query, FetchOptions options) { return datastore.prepare(query).asList(options); }
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(); }
Query q = new Query("Employees"); q.addFilter("is_active", FilterOperator.EQUAL, isActive); q.addSort("first_name", SortDirection.ASCENDING); PreparedQuery pq = datastore.prepare(q); List<Employees> result = pq.asList(FetchOptions.Builder.withOffset(5).limit(5));
private void executeQuery(Query query) { PreparedQuery preparedQuery = service.prepare(query); List<Entity> list = preparedQuery.asList(withDefaults()); list.size(); // only here is the query actually executed } }
private void assertIAEWhenAccessingList(PreparedQuery preparedQuery) { List<Entity> list = preparedQuery.asList(withDefaults()); try { list.size(); fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException ex) { // pass } }
public static void deleteTempData(Class<? extends TempData> type) { // check if in-container if (isInContainer() == false) { return; } String kind = getKind(type); DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); final List<Entity> list = ds.prepare(new Query(kind)).asList(FetchOptions.Builder.withDefaults()); for (Entity e : list) { deleteTempDataInTx(ds, e, type); } }
@Test public void testAsList() throws Exception { List<Entity> list = preparedQuery.asList(withDefaults()); assertNotNull(list); assertEquals(1, list.size()); assertEquals(john, list.get(0)); }
@Test public void testQueryOrder() { Query query = new Query(kindName, rootKey); query.addProjection(new PropertyProjection("intData", Integer.class)); query.addSort("stringData", Query.SortDirection.DESCENDING); List<Entity> results = service.prepare(query).asList(fetchOption); assertEquals(count, results.size()); int first = new Integer(results.get(0).getProperty("intData").toString()); int last = new Integer(results.get(count - 1).getProperty("intData").toString()); assertTrue(first > last); }
private void checkQueryType(String property, Class<?> type) { Query query = new Query(kindName, rootKey); query.addProjection(new PropertyProjection(property, type)); String sql = "SELECT " + property + " FROM " + kindName + " WHERE __ancestor__ is " + rootKey; assertEquals(sql.toLowerCase(), query.toString().toLowerCase()); List<Entity> results = service.prepare(query).asList(fetchOption); for (Entity e : results) { assertEquals(1, e.getProperties().size()); assertTrue(e.getProperties().containsKey(property)); } }
@Test public void testSortPredicates() { Query query = new Query(kindName, rootKey); query.addSort("intData", Query.SortDirection.DESCENDING); List<Entity> es = service.prepare(query).asList(fo); assertEquals((long) 40, es.get(0).getProperty("intData")); List<Query.SortPredicate> qsp = query.getSortPredicates(); assertEquals("check SortPredicate name", "intData", qsp.get(0).getPropertyName()); assertEquals("check SortPredicate direction", Query.SortDirection.DESCENDING, qsp.get(0).getDirection()); }
@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 queriesDontReturnDeletedEntities() throws Exception { String methodName = "queriesDontReturnDeletedEntities"; Entity entity = createTestEntityWithUniqueMethodNameKey(SMOKE_TEST_ENTITY, methodName); Key key = entity.getKey(); service.put(entity); service.delete(key); List<Entity> entities = service.prepare(new Query(SMOKE_TEST_ENTITY).setAncestor(key)) .asList(FetchOptions.Builder.withDefaults()); assertEquals(0, entities.size()); }
private void deleteNsKinds(String namespace, String kind) { String originalNs = NamespaceManager.get(); NamespaceManager.set(namespace); List<Entity> entities = service.prepare(new Query(kind)).asList(withDefaults()); deleteEntityList(entities); NamespaceManager.set(originalNs); }
@Test public void testIntegerPropertySortingIsNotLexicographic() throws Exception { String methodName = "testIntegerPropertySortingIsNotLexicographic"; Entity parent = createTestEntityWithUniqueMethodNameKey(QUERY_SORTING_ENTITY, methodName); Key key = parent.getKey(); Entity ten = storeTestEntityWithSingleProperty(key, 10); Entity five = storeTestEntityWithSingleProperty(key, 5); Query query = createQuery().setAncestor(key).addSort(SINGLE_PROPERTY_NAME, ASCENDING); List<Entity> results = service.prepare(query).asList(withDefaults()); assertTrue(results.indexOf(five) < results.indexOf(ten)); // if sorting were lexicographic, "10" would come before "5" service.delete(ten.getKey(), five.getKey()); }
@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()); }