DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); Query query = new Query("table1"); query.addFilter("id", FilterOperator.EQUAL, "12345"); PreparedQuery pq = datastore.prepare(query); Entity customer = pq.asSingleEntity();
private void assertIAEWhenGettingSingleEntity(PreparedQuery preparedQuery) { try { preparedQuery.asSingleEntity(); fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException ex) { // pass } } }
public static LeanAccount findAccountByProvider(String providerID, String provider) { if (providerID == null) { log.severe("Empty providerID. Can not find account without providerID."); return null; } Query query = new Query(accountsKind); query.addFilter("_provider_id", Query.FilterOperator.EQUAL, providerID); query.addFilter("_provider", Query.FilterOperator.EQUAL, provider); PreparedQuery pq = datastore.prepare(query); Entity accountEntity = pq.asSingleEntity(); return (accountEntity == null) ? null : toLeanAccount(accountEntity); }
public static LeanAccount findAccountByEmail(String email, String provider) { if (email == null) { log.severe("Empty email. Can not find account without email."); return null; } Query query = new Query(accountsKind); query.addFilter("email", Query.FilterOperator.EQUAL, email); query.addFilter("_provider", Query.FilterOperator.EQUAL, provider); PreparedQuery pq = datastore.prepare(query); Entity accountEntity = pq.asSingleEntity(); return (accountEntity == null) ? null : toLeanAccount(accountEntity); }
@Test public void testAsSingleEntity() throws Exception { Entity entity = preparedQuery.asSingleEntity(); assertEquals(john, entity); }
private List<Entity> readMultipleGroup(GroupParentKeys keys) { List<Entity> es = new ArrayList<>(); es.clear(); Query q = new Query(kindName).setAncestor(keys.firstParent); es.add(service.prepare(q).asSingleEntity()); q = new Query(otherKind).setAncestor(keys.secondParent); es.add(service.prepare(q).asSingleEntity()); return es; }
@Test public void testGets() throws Exception { Query query = new Query(kindName, rootKey); GeoPt filter = new GeoPt(Float.valueOf(60).floatValue(), Float.valueOf(145).floatValue()); query.setFilter(new FilterPredicate(propertyName, Query.FilterOperator.EQUAL, filter)); Entity entity = service.prepare(query).asSingleEntity(); GeoPt geopt = (GeoPt) entity.getProperty(propertyName); assertTrue(geopt.equals(filter)); assertEquals(Float.valueOf(geopt.getLatitude()).toString(), Float.valueOf(60).toString()); assertEquals(Float.valueOf(geopt.getLongitude()).toString(), Float.valueOf(145).toString()); }
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; } }
protected void assertSingleResult(Entity expectedEntity, Query query) { PreparedQuery preparedQuery = service.prepare(query); assertEquals("number of results", 1, preparedQuery.countEntities(withDefaults())); Entity entityFromQuery = preparedQuery.asSingleEntity(); assertEquals(expectedEntity, entityFromQuery); }
private Entity fetchEntity(String testMethodTag) { DatastoreService datastoreService = DatastoreServiceFactory.getDatastoreService(); Query query = new Query(entityName); query.setFilter(getTestMethodFilter(testMethodTag)); return datastoreService.prepare(query).asSingleEntity(); } }
@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 testAllowMultipleGroupTrue() throws Exception { clearData(kindName); clearData(otherKind); writeMultipleGroup(true); Query q = new Query(kindName); Entity e = service.prepare(q).asSingleEntity(); assertEquals("parent", e.getProperty("check")); q = new Query(otherKind); e = service.prepare(q).asSingleEntity(); assertEquals("other", e.getProperty("check")); }
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 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 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 testNullPropertyValue() throws Exception { Key parentKey = createQueryBasicsTestParent("testNullPropertyValue"); createEntity("Entry", parentKey) .withProperty("user", null) .store(); Entity entity = service.prepare(new Query("Entry") .setAncestor(parentKey)).asSingleEntity(); assertNull(entity.getProperty("user")); }
@Test public void testFilterEqualNull() throws Exception { Key parentKey = createQueryBasicsTestParent("testFilterEqualNull"); createEntity("Entry", parentKey) .withProperty("user", null) .store(); Query query = new Query("Entry") .setAncestor(parentKey) .setFilter(new Query.FilterPredicate("user", EQUAL, null)); assertNotNull(service.prepare(query).asSingleEntity()); }
@Test public void testFilterNotEqualNull() throws Exception { Key parentKey = createQueryBasicsTestParent("testFilterNotEqualNull"); createEntity("Entry", parentKey) .withProperty("user", "joe") .store(); Query query = new Query("Entry") .setAncestor(parentKey) .setFilter(new Query.FilterPredicate("user", NOT_EQUAL, null)); assertNotNull(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())); }