public static void main(String[] args) throws IOException { String serverString = args[0]; RemoteApiOptions options; if (serverString.equals("localhost")) { options = new RemoteApiOptions().server(serverString, 8080).useDevelopmentServerCredential(); } else { options = new RemoteApiOptions().server(serverString, 443).useApplicationDefaultCredential(); } RemoteApiInstaller installer = new RemoteApiInstaller(); installer.install(options); try { DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); System.out.println("Key of new entity is " + ds.put(new Entity("Hello Remote API!"))); } finally { installer.uninstall(); } } }
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();
DatastoreService service = DatastoreServiceFactory.getDatastoreService(); Query q = new Query("pageText"); PreparedQuery pq = service.prepare(q); PrintWriter out = resp.getWriter(); for (Entity result : pq.asIterable()) { out.println(result.getProperty("pageOwner") + " " + result.getProperty("pageName")); }
Query q = new Query( "YourEntityName" ); q.setFilter( new FilterPredicate( "dateTime", FilterOperator.GREATER_THAN_OR_EQUAL, dayStart ) ); // And execute the query: DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); for ( final Entity e : ds.prepare( q ).asIterable() ) { // Do something with the entity }
DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); Query q = new Query("Entity"); PreparedQuery pq = datastore.prepare(q); for (com.google.appengine.api.datastore.Entity result : pq.asIterable()) { String content = (String) result.getProperty("content"); if (content != null) { result.setProperty("content", new com.google.appengine.api.datastore.Text(content)); datastore.put(result); } }
@Override public void clearData(String kind) { List<Key> elist = new ArrayList<>(); Query query = new Query(kind); for (Entity readRec : service.prepare(query).asIterable()) { elist.add(readRec.getKey()); } service.delete(elist); sync(sleepTime); } }
@Test public void testFilterByEntityKey() { Entity parentEntity = createTestEntityWithUniqueMethodNameKey(TEST_ENTITY_KIND, "testFilterByEntityKey"); Key parentKey = parentEntity.getKey(); Key fooKey = KeyFactory.createKey(parentKey, "foo", 1); Entity fooEntity = new Entity(fooKey); service.put(fooEntity); Query query = new Query("foo") .setAncestor(parentKey) .setFilter(new Query.FilterPredicate(Entity.KEY_RESERVED_PROPERTY, EQUAL, fooKey)); PreparedQuery preparedQuery = service.prepare(query); List<Entity> results = preparedQuery.asList(FetchOptions.Builder.withDefaults()); assertEquals(1, results.size()); assertEquals(fooEntity, results.get(0)); }
Query query = new Query("SomeKind"); query.setFilter(new FilterPredicate("name", FilterOperator.EQUAL, "john")); query.setKeysOnly(); DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); List<Entity> entities = ds.prepare(query).asList(FetchOptions.Builder.withLimit(1)); if(entities.size() == 1) { //Exists! }
@Test public void testGetWithDifferentAncestorsInsideSameTransactionAreNotAllowed() { service.put(new Entity("foo", "1")); service.put(new Entity("foo", "2")); Transaction tx = service.beginTransaction(); try { service.get(Arrays.asList(KeyFactory.createKey("foo", "1"))); try { service.get(Arrays.asList(KeyFactory.createKey("foo", "2"))); fail("Expected IllegalArgumentException"); } catch (IllegalArgumentException e) { // pass } } finally { tx.rollback(); } }
@Override public void setAuthority(String username, String authority) { Key userKey = KeyFactory.createKey(AUTH_FLOWS_USER_DB_KIND, username); Entity entity; try { entity = datastore.get(userKey); log.debug("got entity of " + username + ": " + entity); } catch (EntityNotFoundException e) { log.error("entity of " + username + " not found"); throw new NoSuchElementException(e.getMessage()); } entity.setProperty(AUTHORITIES_PROP_NAME, authority ); datastore.put( entity ); }
@Test public void testKeySerialization() throws EntityNotFoundException, IOException { Key parentKeyB = KeyFactory.createKey("family", "same"); Key childKeyB = KeyFactory.createKey(parentKeyB, "children", "same"); Entity entB1 = new Entity(childKeyB); service.put(entB1); Entity entB2 = service.get(childKeyB); assertEquals(new String(MemcacheSerialization.makePbKey(entB1.getKey())), new String(MemcacheSerialization.makePbKey(childKeyB))); assertEquals(new String(MemcacheSerialization.makePbKey(entB2.getKey())), new String(MemcacheSerialization.makePbKey(childKeyB))); service.delete(childKeyB); service.delete(parentKeyB); }
@Test public void testAncestorKey() { Key pKey = getParent().getKey(); Query query = new Query(CHILDKIND, pKey); query.addSort("__key__"); assertEquals(2, service.prepare(query) .countEntities(FetchOptions.Builder.withDefaults())); for (Entity cRec : service.prepare(query).asIterable()) { assertEquals(pKey, cRec.getParent()); } }
public static AuthToken getAuthToken(String token) { //todo use MemCache Entity tokenEntity; try { tokenEntity = datastore.get(KeyFactory.createKey(authTokenKind, token)); } catch (EntityNotFoundException e) { return null; } return new AuthToken( token, (Long) tokenEntity.getProperty("account"), (Long) tokenEntity.getProperty("time") ); }
@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()); }
Query query = new Query("Issue"); List<String> list = Arrays.asList("NEW", "OPEN", "ACCEPTED"); query.addFilter("status", FilterOperator.IN, list); DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); PreparedQuery preparedQuery = datastore.prepare(query); for (Entity entity : preparedQuery.asIterable()) { // should iterate over 'NEW', 'OPEN' and 'ACCEPTED' issues }
@Before public void createData() throws InterruptedException, ParseException { Date[] testDatas = {dfDateTime.parse("2001,1,1,23,59,59"), dfDateTime.parse("2005,5,5,13,19,19"), dfDateTime.parse("2008,8,8,3,9,9")}; Query q = new Query(kindName, rootKey); if (service.prepare(q).countEntities(FetchOptions.Builder.withDefaults()) == 0) { List<Entity> elist = new ArrayList<Entity>(); for (Date data : testDatas) { Entity newRec = new Entity(kindName, rootKey); newRec.setProperty(propertyName, data); elist.add(newRec); } service.put(elist); sync(waitTime); } }
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()); } }
// Construct then prepare your query List<Entity> get5TallestPeople() { DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); Query q = new Query("Person"); q.addSort("height", SortDirection.DESCENDING); PreparedQuery pq = ds.prepare(q); return pq.asList(FetchOptions.Builder.withLimit(5)); }
@Test public void testQueryWithoutAnyConstraints() throws Exception { Key parentKey = createQueryBasicsTestParent("testQueryWithoutAnyConstraints"); Entity person = new Entity("Person", parentKey); service.put(person); Entity address = new Entity("Address", parentKey); service.put(address); PreparedQuery preparedQuery = service.prepare(new Query().setAncestor(parentKey)); assertTrue(preparedQuery.countEntities(withDefaults()) >= 2); List<Entity> results = preparedQuery.asList(withDefaults()); assertTrue(results.containsAll(Arrays.asList(person, address))); }
DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); Query query = new Query("table1"); query.addFilter("id", FilterOperator.EQUAL, "12345"); PreparedQuery pq = datastore.prepare(query); Entity customer = pq.asSingleEntity();