private Entity createEntity(Key key, Map<String, Object> data) throws IOException { Entity.Builder builder = Entity.newBuilder(key).set(CREATED_FIELD, Timestamp.now()); for (Entry<String, Object> entry : data.entrySet()) { if (entry.getValue() instanceof String) { builder.set(entry.getKey(), (String) entry.getValue()); // StringValue } else if (entry.getValue() instanceof Integer) { builder.set(entry.getKey(), (Integer) entry.getValue()); // LongValue } else if (entry.getValue() instanceof Double) { builder.set(entry.getKey(), (Double) entry.getValue()); // DoubleValue } else if (entry.getValue() instanceof Boolean) { builder.set(entry.getKey(), (Boolean) entry.getValue()); // BooleanValue } else if (entry.getValue() instanceof Timestamp) { builder.set(entry.getKey(), (Timestamp) entry.getValue()); // TimestampValue } else { ByteArrayOutputStream bos = new ByteArrayOutputStream(); try (ObjectOutputStream out = new ObjectOutputStream(bos)) { out.writeObject(entry.getValue()); } builder.set(entry.getKey(), Blob.copyFrom(bos.toByteArray())); // BlobValue } } return builder.build(); }
@Override public <T extends DataModel> void create(UUID jobId, String key, T model) throws IOException { Preconditions.checkNotNull(jobId); Transaction transaction = datastore.newTransaction(); Key fullKey = getDataKey(jobId, key); Entity shouldNotExist = transaction.get(fullKey); if (shouldNotExist != null) { transaction.rollback(); throw new IOException( "Record already exists for key: " + fullKey.getName() + ". Record: " + shouldNotExist); } String serialized = objectMapper.writeValueAsString(model); Entity entity = Entity.newBuilder(fullKey) .set(CREATED_FIELD, Timestamp.now()) .set(model.getClass().getName(), serialized) .build(); try { transaction.put(entity); } catch (DatastoreException e) { throw new IOException( "Could not create initial record for jobID: " + jobId + ". Record: " + entity, e); } transaction.commit(); }
@Override public <T extends DataModel> void update(UUID jobId, String key, T model) { Transaction transaction = datastore.newTransaction(); Key entityKey = getDataKey(jobId, key); try { Entity previousEntity = transaction.get(entityKey); if (previousEntity == null) { throw new IOException("Could not find record for data key: " + entityKey.getName()); } String serialized = objectMapper.writeValueAsString(model); Entity entity = Entity.newBuilder(entityKey) .set(CREATED_FIELD, Timestamp.now()) .set(model.getClass().getName(), serialized) .build(); transaction.put(entity); transaction.commit(); } catch (IOException t) { transaction.rollback(); throw new RuntimeException("Failed atomic update of key: " + key, t); } }
@Test public void testUpdate() { List<Entity> keys = datastore.fetch(ENTITY1.getKey(), ENTITY3.getKey()); assertEquals(ENTITY1, keys.get(0)); assertNull(keys.get(1)); assertEquals(2, keys.size()); try { datastore.update(ENTITY3); fail("Expecting a failure"); } catch (DatastoreException expected) { // expected; } datastore.add(ENTITY3); assertEquals(ENTITY3, datastore.get(ENTITY3.getKey())); Entity entity3 = Entity.newBuilder(ENTITY3).clear().set("bla", new NullValue()).build(); assertNotEquals(ENTITY3, entity3); datastore.update(entity3); assertEquals(entity3, datastore.get(ENTITY3.getKey())); }
/** Example of starting a new batch. */ // [TARGET newBatch()] // [VARIABLE "my_key_name_1"] // [VARIABLE "my_key_name_2"] public Batch newBatch(String keyName1, String keyName2) { // [START newBatch] Key key1 = datastore.newKeyFactory().setKind("MyKind").newKey(keyName1); Key key2 = datastore.newKeyFactory().setKind("MyKind").newKey(keyName2); Batch batch = datastore.newBatch(); Entity entity1 = Entity.newBuilder(key1).set("name", "John").build(); Entity entity2 = Entity.newBuilder(key2).set("title", "title").build(); batch.add(entity1); batch.add(entity2); batch.submit(); // [END newBatch] return batch; }
/** Example of putting multiple entities. */ // [TARGET put(FullEntity...)] // [VARIABLE "my_key_name1"] // [VARIABLE "my_key_name2"] public void batchPutEntities(String keyName1, String keyName2) { // [START batchPutEntities] Key key1 = datastore.newKeyFactory().setKind("MyKind").newKey(keyName1); Entity.Builder entityBuilder1 = Entity.newBuilder(key1); entityBuilder1.set("propertyName", "value1"); Entity entity1 = entityBuilder1.build(); Key key2 = datastore.newKeyFactory().setKind("MyKind").newKey(keyName2); Entity.Builder entityBuilder2 = Entity.newBuilder(key2); entityBuilder2.set("propertyName", "value2"); Entity entity2 = entityBuilder2.build(); datastore.put(entity1, entity2); // [END batchPutEntities] }
@Override public void run(Transaction tx, Key userKey, Contact contact) { Entity user = tx.get(userKey); if (user == null) { System.out.println("Adding a new user."); user = Entity.newBuilder(userKey).set("count", 0L).build(); tx.add(user); } FullEntity<IncompleteKey> contactEntity = FullEntity.newBuilder() .set("email", contact.email()) .set("phone", contact.phone()) .build(); tx.update(Entity.newBuilder(user).set("contact", contactEntity).build()); System.out.printf("Setting contact for user '%s'.%n", userKey.getName()); }
/** 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; }
/** 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] }
/** 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] }
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); } }
@Test public void testPutAfterUpdate() throws Exception { Entity entity = Entity.newBuilder(ENTITY1).set("foo", "bar").build(); List<com.google.datastore.v1.Mutation> pbs = new LinkedList<>(); pbs.add(com.google.datastore.v1.Mutation.newBuilder().setUpsert(entity.toPb()).build()); batchWriter.update(ENTITY1); Entity putEntity = batchWriter.put(entity); assertEquals(entity, putEntity); assertEquals(pbs, batchWriter.toMutationPbList()); }
@Test public void testUpdateAfterUpdate() throws Exception { Entity entity = Entity.newBuilder(ENTITY1).set("foo", "bar").build(); List<com.google.datastore.v1.Mutation> pbs = new LinkedList<>(); pbs.add(com.google.datastore.v1.Mutation.newBuilder().setUpdate(entity.toPb()).build()); batchWriter.update(ENTITY1); batchWriter.update(entity); assertEquals(pbs, batchWriter.toMutationPbList()); }
@Test public void testPutAfterDelete() throws Exception { Entity entity = Entity.newBuilder(ENTITY1).set("foo", "bar").build(); List<com.google.datastore.v1.Mutation> pbs = new LinkedList<>(); pbs.add(com.google.datastore.v1.Mutation.newBuilder().setUpsert(entity.toPb()).build()); batchWriter.delete(KEY1); Entity putEntity = batchWriter.put(entity); assertEquals(entity, putEntity); assertEquals(pbs, batchWriter.toMutationPbList()); }
@Test public void testPutAfterPut() throws Exception { Entity entity = Entity.newBuilder(ENTITY1).set("foo", "bar").build(); List<com.google.datastore.v1.Mutation> pbs = new LinkedList<>(); pbs.add(com.google.datastore.v1.Mutation.newBuilder().setUpsert(entity.toPb()).build()); Entity putEntity1 = batchWriter.put(ENTITY1); Entity putEntity2 = batchWriter.put(entity); assertEquals(ENTITY1, putEntity1); assertEquals(entity, putEntity2); assertEquals(pbs, batchWriter.toMutationPbList()); }
@Test public void testUpdateAfterPut() throws Exception { Entity entity = Entity.newBuilder(ENTITY1).set("foo", "bar").build(); List<com.google.datastore.v1.Mutation> pbs = new LinkedList<>(); pbs.add(com.google.datastore.v1.Mutation.newBuilder().setUpsert(entity.toPb()).build()); batchWriter.put(ENTITY1); batchWriter.update(entity); assertEquals(pbs, batchWriter.toMutationPbList()); }
@Test public void testUpdateAfterAdd() throws Exception { Entity entity = Entity.newBuilder(ENTITY1).set("foo", "bar").build(); List<com.google.datastore.v1.Mutation> pbs = new LinkedList<>(); pbs.add(com.google.datastore.v1.Mutation.newBuilder().setUpsert(entity.toPb()).build()); batchWriter.add(ENTITY1); batchWriter.update(entity); assertEquals(pbs, batchWriter.toMutationPbList()); }
/** 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 testPutAfterAdd() throws Exception { Entity entity = Entity.newBuilder(ENTITY1).set("foo", "bar").build(); List<com.google.datastore.v1.Mutation> pbs = new LinkedList<>(); pbs.add(com.google.datastore.v1.Mutation.newBuilder().setUpsert(entity.toPb()).build()); batchWriter.add(ENTITY1); batchWriter.put(entity); assertEquals(pbs, batchWriter.toMutationPbList()); }
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); } } }