private Builder(Key copyFrom) { super(copyFrom); if (copyFrom.hasId()) { id = copyFrom.getId(); } else { name = copyFrom.getName(); } }
private static void addParentToBuilder(Key parent, Builder builder) { builder.setNamespace(parent.getNamespace()); builder.addAncestors(parent.getAncestors()); if (parent.hasId()) { builder.addAncestors(PathElement.of(parent.getKind(), parent.getId())); } else { builder.addAncestors(PathElement.of(parent.getKind(), parent.getName())); } } }
@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(); }
@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); }
@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); } }
private void verifyKey(Key key, String name, String namespace, PathElement... ancestors) { assertEquals(name, key.getName()); verifyIncompleteKey(key, namespace, ancestors); }
Entity user = tx.get(userKey); if (user == null) { System.out.printf("User '%s' does not exist.%n", userKey.getName()); return; String phone = contact.getString("phone"); System.out.printf( "User '%s' email is '%s', phone is '%s'.%n", userKey.getName(), email, phone); System.out.printf("User '%s' has %d comment[s].%n", userKey.getName(), user.getLong("count")); int limit = 200; Map<Timestamp, String> sortedComments = new TreeMap<>();
/** * Finds the ID of the first {@link PortabilityJob} in state {@code jobState} in Datastore, or * null if none found. * * <p>TODO(rtannenbaum): Order by creation time so we can process jobs in a FIFO manner. Trying * to OrderBy.asc("created") currently fails because we don't yet have an index set up. */ @Override public UUID findFirst(JobAuthorization.State jobState) { Query<Key> query = Query.newKeyQueryBuilder() .setKind(KIND) .setFilter(PropertyFilter.eq(PortabilityJob.AUTHORIZATION_STATE, jobState.name())) // .setOrderBy(OrderBy.asc("created")) .setLimit(1) .build(); QueryResults<Key> results = datastore.run(query); if (!results.hasNext()) { return null; } Key key = results.next(); return UUID.fromString(key.getName()); }
@Override public void run(Transaction tx, Key userKey, Void arg) { Entity user = tx.get(userKey); if (user == null) { System.out.println("Nothing to delete, user does not exist."); return; } Query<Key> query = Query.newKeyQueryBuilder() .setNamespace(NAMESPACE) .setKind(COMMENT_KIND) .setFilter(PropertyFilter.hasAncestor(userKey)) .build(); QueryResults<Key> comments = tx.run(query); int count = 0; while (comments.hasNext()) { tx.delete(comments.next()); count++; } tx.delete(userKey); System.out.printf("Deleting user '%s' and %d comment[s].%n", userKey.getName(), count); }
@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()); }
/** * @return the name associated with this key, or null if this key has an id */ public String getName() { return this.raw.getName(); }
@Override public void run(Transaction tx, Key userKey, String content) { Entity user = tx.get(userKey); if (user == null) { System.out.println("Adding a new user."); user = Entity.newBuilder(userKey).set("count", 1).build(); tx.add(user); } else { user = Entity.newBuilder(user).set("count", user.getLong("count") + 1L).build(); tx.update(user); } IncompleteKey commentKey = IncompleteKey.newBuilder(userKey, COMMENT_KIND).build(); FullEntity<IncompleteKey> comment = FullEntity.newBuilder(commentKey) .set("content", content) .set("timestamp", Timestamp.now()) .build(); tx.addWithDeferredIdAllocation(comment); System.out.printf("Adding a comment to user '%s'.%n", userKey.getName()); }
/** * Gets the String or Long id from the key as a Value, or null if incomplete */ @SuppressWarnings("unchecked") public static <S> Value<S> getIdValue(final IncompleteKey key) { if (key instanceof com.google.cloud.datastore.Key) { final com.google.cloud.datastore.Key completeKey = (com.google.cloud.datastore.Key)key; if (completeKey.hasId()) return (Value<S>)LongValue.of(completeKey.getId()); else return (Value<S>)StringValue.of(completeKey.getName()); } else { return null; } }
public static void main(String... args) throws Exception { // Instantiates a client Datastore datastore = DatastoreOptions.getDefaultInstance().getService(); // The kind for the new entity String kind = "Task"; // The name/ID for the new entity String name = "sampletask1"; // The Cloud Datastore key for the new entity Key taskKey = datastore.newKeyFactory().setKind(kind).newKey(name); // Prepares the new entity Entity task = Entity.newBuilder(taskKey) .set("description", "Buy milk") .build(); // Saves the entity datastore.put(task); System.out.printf("Saved %s: %s%n", task.getKey().getName(), task.getString("description")); //Retrieve entity Entity retrieved = datastore.get(taskKey); System.out.printf("Retrieved %s: %s%n", taskKey.getName(), retrieved.getString("description")); } }
DynamicMessage.Builder elementMessageBuilder = DynamicMessage.newBuilder(elementDescriptor); elementMessageBuilder.setField(elementDescriptor.findFieldByName("type"), key.getKind()); if (key.getName() != null) { elementMessageBuilder.setField(elementDescriptor.findFieldByName("name"), key.getName()); } else { elementMessageBuilder.setField(elementDescriptor.findFieldByName("id"), key.getId());
private Builder(Key copyFrom) { super(copyFrom); if (copyFrom.hasId()) { id = copyFrom.getId(); } else { name = copyFrom.getName(); } }
private WorkflowId parseWorkflowId(Entity workflow) { final String componentId = workflow.getKey().getAncestors().get(0).getName(); final String id = workflow.getKey().getName(); return WorkflowId.create(componentId, id); }