/** Deletes all entities in the namespace associated with this {@link RemoteDatastoreHelper}. */ public void deleteNamespace() { StructuredQuery<Key> query = Query.newKeyQueryBuilder().setNamespace(namespace).build(); QueryResults<Key> keys = datastore.run(query); while (keys.hasNext()) { datastore.delete(keys.next()); } }
/** 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] }
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())); } } }
/** 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 creating and running an entity query. */ // [TARGET newEntityQueryBuilder()] // [VARIABLE "my_kind"] public QueryResults<Entity> newEntityQuery(String kind) { // [START newEntityQuery] Query<Entity> query = Query.newEntityQueryBuilder().setKind(kind).build(); QueryResults<Entity> results = datastore.run(query); // Use results // [END newEntityQuery] return results; }
/** Example of creating and running a key query. */ // [TARGET newKeyQueryBuilder()] // [VARIABLE "my_kind"] public QueryResults<Key> newKeyQuery(String kind) { // [START newKeyQuery] Query<Key> query = Query.newKeyQueryBuilder().setKind(kind).build(); QueryResults<Key> results = datastore.run(query); // Use results // [END newKeyQuery] return results; }
@Test public void mergeFrom() { compareMergedQuery( ENTITY_QUERY, new EntityQuery.Builder().mergeFrom(ENTITY_QUERY.toPb()).build()); compareMergedQuery(KEY_QUERY, new KeyQuery.Builder().mergeFrom(KEY_QUERY.toPb()).build()); compareMergedQuery( PROJECTION_QUERY, new ProjectionEntityQuery.Builder().mergeFrom(PROJECTION_QUERY.toPb()).build()); }
/** Example of creating and running a GQL query. */ // [TARGET newGqlQueryBuilder(String)] // [VARIABLE "my_kind"] public QueryResults<?> newQuery(String kind) { // [START newQuery] String gqlQuery = "select * from " + kind; Query<?> query = Query.newGqlQueryBuilder(gqlQuery).build(); QueryResults<?> results = datastore.run(query); // Use results // [END newQuery] return results; }
public static Builder newBuilder(Key parent, String kind) { return newBuilder(parent.getProjectId(), kind) .setNamespace(parent.getNamespace()) .addAncestors(parent.getPath()); } }
@Override public B mergeFrom(P other) { excludeFromIndexes = other.excludeFromIndexes(); meaning = other.getMeaning(); set(other.get()); return self(); }
/** Sets the project ID of the key. */ public B setProjectId(String projectId) { this.projectId = validateDatabase(projectId); return self(); }
/** Sets the namespace of the key. */ public B setNamespace(String namespace) { this.namespace = validateNamespace(namespace); return self(); }
/** Example of creating and running a typed GQL query. */ // [TARGET newGqlQueryBuilder(ResultType, String)] // [VARIABLE "my_kind"] public QueryResults<Entity> newTypedQuery(String kind) { // [START newTypedQuery] String gqlQuery = "select * from " + kind; Query<Entity> query = Query.newGqlQueryBuilder(Query.ResultType.ENTITY, gqlQuery).build(); QueryResults<Entity> results = datastore.run(query); // Use results // [END newTypedQuery] return results; }
/** * Returns the property value as a list of values. * * @throws DatastoreException if no such property * @throws ClassCastException if value is not a list of values */ @SuppressWarnings("unchecked") public <T extends Value<?>> List<T> getList(String name) { return (List<T>) getValue(name).get(); }
/** * Returns the property value as an entity. * * @throws DatastoreException if no such property * @throws ClassCastException if value is not an entity */ @SuppressWarnings("unchecked") public <K extends IncompleteKey> FullEntity<K> getEntity(String name) { return ((Value<FullEntity<K>>) getValue(name)).get(); }