@Override protected IncompleteKey build() { return newKey(); } }
/** Example of allocating multiple ids in a single batch. */ // [TARGET allocateId(IncompleteKey...)] public List<Key> batchAllocateId() { // [START batchAllocateId] KeyFactory keyFactory = datastore.newKeyFactory().setKind("MyKind"); IncompleteKey incompleteKey1 = keyFactory.newKey(); IncompleteKey incompleteKey2 = keyFactory.newKey(); // let cloud datastore automatically assign the ids List<Key> keys = datastore.allocateId(incompleteKey1, incompleteKey2); // [END batchAllocateId] return keys; }
private Key getKey(UUID jobId) { return datastore.newKeyFactory().setKind(KIND).newKey(jobId.toString()); }
/** Example of deleting multiple entities. */ // [TARGET delete(Key...)] // [VARIABLE "my_key_name1"] // [VARIABLE "my_key_name2"] public void batchDeleteEntities(String keyName1, String keyName2) { // [START batchDeleteEntities] Key key1 = datastore.newKeyFactory().setKind("MyKind").newKey(keyName1); Key key2 = datastore.newKeyFactory().setKind("MyKind").newKey(keyName2); datastore.delete(key1, key2); // [END batchDeleteEntities] }
/** Example of allocating an id. */ // [TARGET allocateId(IncompleteKey)] public Key allocateIdSingle() { // [START allocateIdSingle] KeyFactory keyFactory = datastore.newKeyFactory().setKind("MyKind"); IncompleteKey incompleteKey = keyFactory.newKey(); // let cloud datastore automatically assign an id Key key = datastore.allocateId(incompleteKey); // [END allocateIdSingle] return key; }
/** Example of getting an entity. */ // [TARGET get(Key, ReadOption...)] // [VARIABLE "my_key_name"] public Entity getEntityWithKey(String keyName) { // [START getEntityWithKey] Key key = datastore.newKeyFactory().setKind("MyKind").newKey(keyName); Entity entity = datastore.get(key); // Do something with the entity // [END getEntityWithKey] return entity; }
private Key getDataKey(UUID jobId, String key) { return datastore.newKeyFactory().setKind(KIND).newKey(getDataKeyName(jobId, key)); }
/** Example of deleting multiple entities. */ // [TARGET delete(Key...)] // [VARIABLE "my_key_name1"] // [VARIABLE "my_key_name2"] public void multipleDeleteEntities(String keyName1, String keyName2) { Datastore datastore = transaction.getDatastore(); // [START multipleDeleteEntities] Key key1 = datastore.newKeyFactory().setKind("MyKind").newKey(keyName1); Key key2 = datastore.newKeyFactory().setKind("MyKind").newKey(keyName2); transaction.delete(key1, key2); transaction.commit(); // [END multipleDeleteEntities] }
/** Example of getting an entity for a given key. */ // [TARGET get(Key)] // [VARIABLE "my_key_name"] public Entity get(String keyName) { Datastore datastore = transaction.getDatastore(); // [START get] Key key = datastore.newKeyFactory().setKind("MyKind").newKey(keyName); Entity entity = transaction.get(key); transaction.commit(); // Do something with the entity // [END get] return entity; }
/** Example of putting a single entity. */ // [TARGET put(FullEntity)] // [VARIABLE "my_key_name"] public void putSingleEntity(String keyName) { // [START putSingleEntity] Key key = datastore.newKeyFactory().setKind("MyKind").newKey(keyName); Entity.Builder entityBuilder = Entity.newBuilder(key); entityBuilder.set("propertyName", "value"); Entity entity = entityBuilder.build(); datastore.put(entity); // [END putSingleEntity] }
@Test public void testNewKey() throws Exception { Key key = keyFactory.newKey(1); verifyKey(key, 1L, ""); key = keyFactory.newKey("n"); verifyKey(key, "n", ""); PathElement p1 = PathElement.of("k1", "n"); PathElement p2 = PathElement.of("k2", 10); key = keyFactory.setNamespace("ns").addAncestors(p1, p2).newKey("k3"); verifyKey(key, "k3", "ns", p1, p2); }
public static void main(String... args) { Datastore datastore = DatastoreOptions.getDefaultInstance().getService(); KeyFactory keyFactory = datastore.newKeyFactory().setKind("keyKind"); Key key = keyFactory.newKey("keyName"); Entity entity = datastore.get(key); if (entity != null) { System.out.println("Updating access_time for " + entity.getString("name")); entity = Entity.newBuilder(entity).set("access_time", Timestamp.now()).build(); datastore.update(entity); } } }
@Test public void testNewIncompleteKey() throws Exception { IncompleteKey key = keyFactory.newKey(); verifyIncompleteKey(key, ""); PathElement p1 = PathElement.of("k1", "n"); PathElement p2 = PathElement.of("k2", 10); key = keyFactory.setNamespace("ns").addAncestors(p1, p2).newKey(); verifyIncompleteKey(key, "ns", p1, p2); }
@Test public void testKeyFactory() { KeyFactory keyFactory = datastore.newKeyFactory().setKind(KIND1); assertEquals(INCOMPLETE_KEY1, keyFactory.newKey()); assertEquals( IncompleteKey.newBuilder(INCOMPLETE_KEY1).setKind(KIND2).build(), datastore.newKeyFactory().setKind(KIND2).newKey()); assertEquals(KEY1, keyFactory.newKey("name")); assertEquals(Key.newBuilder(KEY1).setId(2).build(), keyFactory.newKey(2)); }
/** Example of putting a single entity. */ // [TARGET put(FullEntity)] // [VARIABLE "my_key_name"] public void putSingleEntity(String keyName) { Datastore datastore = transaction.getDatastore(); // [START putSingleEntity] Key key = datastore.newKeyFactory().setKind("MyKind").newKey(keyName); Entity.Builder entityBuilder = Entity.newBuilder(key); entityBuilder.set("propertyName", "value"); Entity entity = entityBuilder.build(); transaction.put(entity); transaction.commit(); // [END putSingleEntity] }
/** Example of adding a single entity. */ // [TARGET add(FullEntity)] // [VARIABLE "my_key_name"] public void addSingleEntity(String keyName) { Datastore datastore = transaction.getDatastore(); // [START addSingleEntity] Key key = datastore.newKeyFactory().setKind("MyKind").newKey(keyName); Entity.Builder entityBuilder = Entity.newBuilder(key); entityBuilder.set("propertyName", "value"); Entity entity = entityBuilder.build(); transaction.add(entity); transaction.commit(); // [END addSingleEntity] }
@Test public void testAllocateIdArray() { KeyFactory keyFactory = DATASTORE.newKeyFactory().setKind(KIND1); IncompleteKey incompleteKey1 = keyFactory.newKey(); IncompleteKey incompleteKey2 = keyFactory.setKind(KIND2).addAncestors(PathElement.of(KIND1, 10)).newKey(); List<Key> result = DATASTORE.allocateId(incompleteKey1, incompleteKey2, incompleteKey1); assertEquals(3, result.size()); assertEquals(Key.newBuilder(incompleteKey1, result.get(0).getId()).build(), result.get(0)); assertEquals(Key.newBuilder(incompleteKey1, result.get(2).getId()).build(), result.get(2)); assertEquals(Key.newBuilder(incompleteKey2, result.get(1).getId()).build(), result.get(1)); }
@Test public void testNewKeyFactory() { DatastoreOptions options = createMock(DatastoreOptions.class); expect(options.getProjectId()).andReturn("ds1").once(); expect(options.getNamespace()).andReturn("ns1").once(); replay(options); KeyFactory keyFactory = DatastoreHelper.newKeyFactory(options); Key key = keyFactory.setKind("k").newKey("bla"); assertEquals("ds1", key.getProjectId()); assertEquals("ns1", key.getNamespace()); assertEquals("k", key.getKind()); assertEquals("bla", key.getName()); verify(options); }
/** Example of rolling back a transaction. */ // [TARGET rollback()] public Key rollback() { Datastore datastore = transaction.getDatastore(); // [START rollback] // create an entity KeyFactory keyFactory = datastore.newKeyFactory().setKind("MyKind"); Key key = datastore.allocateId(keyFactory.newKey()); Entity entity = Entity.newBuilder(key).set("description", "rollback()").build(); // add the entity and rollback transaction.put(entity); transaction.rollback(); // calling transaction.commit() now would fail // [END rollback] return key; }
public static void main(String... args) { Datastore datastore = DatastoreOptions.getDefaultInstance().getService(); KeyFactory keyFactory = datastore.newKeyFactory().setKind("keyKind"); Key key = keyFactory.newKey("keyName"); Entity entity = Entity.newBuilder(key) .set("name", "John Doe") .set("age", 30) .set("access_time", Timestamp.now()) .build(); datastore.put(entity); } }