public static final class Key.Builder extends GeneratedMessageV3.Builder<Key.Builder> implements KeyOrBuilderA unique identifier for an entity. If a key's partition ID or any of its path kinds or names are reserved/read-only, the key is reserved/read-only. A reserved/read-only key is forbidden in certain documented contexts.
Protobuf type google.datastore.v1.Key
Inheritance
Object > AbstractMessageLite.Builder<MessageType,BuilderType> > AbstractMessage.Builder<BuilderType> > GeneratedMessageV3.Builder > Key.BuilderImplements
KeyOrBuilderStatic Methods
getDescriptor()
public static final Descriptors.Descriptor getDescriptor()| Returns | |
|---|---|
| Type | Description |
Descriptor | |
Methods
addAllPath(Iterable<? extends Key.PathElement> values)
public Key.Builder addAllPath(Iterable<? extends Key.PathElement> values)The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element identifies a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors.
An entity path is always fully complete: all of the entity's ancestors
are required to be in the path along with the entity identifier itself.
The only exception is that in some documented cases, the identifier in the
last path element (for the entity) itself may be omitted. For example,
the last path element of the key of Mutation.insert may have no
identifier.
A path can never be empty, and a path can have at most 100 elements.
repeated .google.datastore.v1.Key.PathElement path = 2;
| Parameter | |
|---|---|
| Name | Description |
values | Iterable<? extends com.google.datastore.v1.Key.PathElement> |
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
addPath(Key.PathElement value)
public Key.Builder addPath(Key.PathElement value)The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element identifies a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors.
An entity path is always fully complete: all of the entity's ancestors
are required to be in the path along with the entity identifier itself.
The only exception is that in some documented cases, the identifier in the
last path element (for the entity) itself may be omitted. For example,
the last path element of the key of Mutation.insert may have no
identifier.
A path can never be empty, and a path can have at most 100 elements.
repeated .google.datastore.v1.Key.PathElement path = 2;
| Parameter | |
|---|---|
| Name | Description |
value | Key.PathElement |
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
addPath(Key.PathElement.Builder builderForValue)
public Key.Builder addPath(Key.PathElement.Builder builderForValue)The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element identifies a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors.
An entity path is always fully complete: all of the entity's ancestors
are required to be in the path along with the entity identifier itself.
The only exception is that in some documented cases, the identifier in the
last path element (for the entity) itself may be omitted. For example,
the last path element of the key of Mutation.insert may have no
identifier.
A path can never be empty, and a path can have at most 100 elements.
repeated .google.datastore.v1.Key.PathElement path = 2;
| Parameter | |
|---|---|
| Name | Description |
builderForValue | Key.PathElement.Builder |
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
addPath(int index, Key.PathElement value)
public Key.Builder addPath(int index, Key.PathElement value)The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element identifies a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors.
An entity path is always fully complete: all of the entity's ancestors
are required to be in the path along with the entity identifier itself.
The only exception is that in some documented cases, the identifier in the
last path element (for the entity) itself may be omitted. For example,
the last path element of the key of Mutation.insert may have no
identifier.
A path can never be empty, and a path can have at most 100 elements.
repeated .google.datastore.v1.Key.PathElement path = 2;
| Parameters | |
|---|---|
| Name | Description |
index | int |
value | Key.PathElement |
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
addPath(int index, Key.PathElement.Builder builderForValue)
public Key.Builder addPath(int index, Key.PathElement.Builder builderForValue)The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element identifies a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors.
An entity path is always fully complete: all of the entity's ancestors
are required to be in the path along with the entity identifier itself.
The only exception is that in some documented cases, the identifier in the
last path element (for the entity) itself may be omitted. For example,
the last path element of the key of Mutation.insert may have no
identifier.
A path can never be empty, and a path can have at most 100 elements.
repeated .google.datastore.v1.Key.PathElement path = 2;
| Parameters | |
|---|---|
| Name | Description |
index | int |
builderForValue | Key.PathElement.Builder |
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
addPathBuilder()
public Key.PathElement.Builder addPathBuilder()The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element identifies a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors.
An entity path is always fully complete: all of the entity's ancestors
are required to be in the path along with the entity identifier itself.
The only exception is that in some documented cases, the identifier in the
last path element (for the entity) itself may be omitted. For example,
the last path element of the key of Mutation.insert may have no
identifier.
A path can never be empty, and a path can have at most 100 elements.
repeated .google.datastore.v1.Key.PathElement path = 2;
| Returns | |
|---|---|
| Type | Description |
Key.PathElement.Builder | |
addPathBuilder(int index)
public Key.PathElement.Builder addPathBuilder(int index)The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element identifies a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors.
An entity path is always fully complete: all of the entity's ancestors
are required to be in the path along with the entity identifier itself.
The only exception is that in some documented cases, the identifier in the
last path element (for the entity) itself may be omitted. For example,
the last path element of the key of Mutation.insert may have no
identifier.
A path can never be empty, and a path can have at most 100 elements.
repeated .google.datastore.v1.Key.PathElement path = 2;
| Parameter | |
|---|---|
| Name | Description |
index | int |
| Returns | |
|---|---|
| Type | Description |
Key.PathElement.Builder | |
addRepeatedField(Descriptors.FieldDescriptor field, Object value)
public Key.Builder addRepeatedField(Descriptors.FieldDescriptor field, Object value)| Parameters | |
|---|---|
| Name | Description |
field | FieldDescriptor |
value | Object |
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
build()
public Key build()| Returns | |
|---|---|
| Type | Description |
Key | |
buildPartial()
public Key buildPartial()| Returns | |
|---|---|
| Type | Description |
Key | |
clear()
public Key.Builder clear()| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
clearField(Descriptors.FieldDescriptor field)
public Key.Builder clearField(Descriptors.FieldDescriptor field)| Parameter | |
|---|---|
| Name | Description |
field | FieldDescriptor |
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
clearOneof(Descriptors.OneofDescriptor oneof)
public Key.Builder clearOneof(Descriptors.OneofDescriptor oneof)| Parameter | |
|---|---|
| Name | Description |
oneof | OneofDescriptor |
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
clearPartitionId()
public Key.Builder clearPartitionId()Entities are partitioned into subsets, currently identified by a project ID and namespace ID. Queries are scoped to a single partition.
.google.datastore.v1.PartitionId partition_id = 1;
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
clearPath()
public Key.Builder clearPath()The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element identifies a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors.
An entity path is always fully complete: all of the entity's ancestors
are required to be in the path along with the entity identifier itself.
The only exception is that in some documented cases, the identifier in the
last path element (for the entity) itself may be omitted. For example,
the last path element of the key of Mutation.insert may have no
identifier.
A path can never be empty, and a path can have at most 100 elements.
repeated .google.datastore.v1.Key.PathElement path = 2;
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
clone()
public Key.Builder clone()| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
getDefaultInstanceForType()
public Key getDefaultInstanceForType()| Returns | |
|---|---|
| Type | Description |
Key | |
getDescriptorForType()
public Descriptors.Descriptor getDescriptorForType()| Returns | |
|---|---|
| Type | Description |
Descriptor | |
getPartitionId()
public PartitionId getPartitionId()Entities are partitioned into subsets, currently identified by a project ID and namespace ID. Queries are scoped to a single partition.
.google.datastore.v1.PartitionId partition_id = 1;
| Returns | |
|---|---|
| Type | Description |
PartitionId | The partitionId. |
getPartitionIdBuilder()
public PartitionId.Builder getPartitionIdBuilder()Entities are partitioned into subsets, currently identified by a project ID and namespace ID. Queries are scoped to a single partition.
.google.datastore.v1.PartitionId partition_id = 1;
| Returns | |
|---|---|
| Type | Description |
PartitionId.Builder | |
getPartitionIdOrBuilder()
public PartitionIdOrBuilder getPartitionIdOrBuilder()Entities are partitioned into subsets, currently identified by a project ID and namespace ID. Queries are scoped to a single partition.
.google.datastore.v1.PartitionId partition_id = 1;
| Returns | |
|---|---|
| Type | Description |
PartitionIdOrBuilder | |
getPath(int index)
public Key.PathElement getPath(int index)The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element identifies a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors.
An entity path is always fully complete: all of the entity's ancestors
are required to be in the path along with the entity identifier itself.
The only exception is that in some documented cases, the identifier in the
last path element (for the entity) itself may be omitted. For example,
the last path element of the key of Mutation.insert may have no
identifier.
A path can never be empty, and a path can have at most 100 elements.
repeated .google.datastore.v1.Key.PathElement path = 2;
| Parameter | |
|---|---|
| Name | Description |
index | int |
| Returns | |
|---|---|
| Type | Description |
Key.PathElement | |
getPathBuilder(int index)
public Key.PathElement.Builder getPathBuilder(int index)The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element identifies a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors.
An entity path is always fully complete: all of the entity's ancestors
are required to be in the path along with the entity identifier itself.
The only exception is that in some documented cases, the identifier in the
last path element (for the entity) itself may be omitted. For example,
the last path element of the key of Mutation.insert may have no
identifier.
A path can never be empty, and a path can have at most 100 elements.
repeated .google.datastore.v1.Key.PathElement path = 2;
| Parameter | |
|---|---|
| Name | Description |
index | int |
| Returns | |
|---|---|
| Type | Description |
Key.PathElement.Builder | |
getPathBuilderList()
public List<Key.PathElement.Builder> getPathBuilderList()The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element identifies a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors.
An entity path is always fully complete: all of the entity's ancestors
are required to be in the path along with the entity identifier itself.
The only exception is that in some documented cases, the identifier in the
last path element (for the entity) itself may be omitted. For example,
the last path element of the key of Mutation.insert may have no
identifier.
A path can never be empty, and a path can have at most 100 elements.
repeated .google.datastore.v1.Key.PathElement path = 2;
| Returns | |
|---|---|
| Type | Description |
List<Builder> | |
getPathCount()
public int getPathCount()The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element identifies a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors.
An entity path is always fully complete: all of the entity's ancestors
are required to be in the path along with the entity identifier itself.
The only exception is that in some documented cases, the identifier in the
last path element (for the entity) itself may be omitted. For example,
the last path element of the key of Mutation.insert may have no
identifier.
A path can never be empty, and a path can have at most 100 elements.
repeated .google.datastore.v1.Key.PathElement path = 2;
| Returns | |
|---|---|
| Type | Description |
int | |
getPathList()
public List<Key.PathElement> getPathList()The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element identifies a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors.
An entity path is always fully complete: all of the entity's ancestors
are required to be in the path along with the entity identifier itself.
The only exception is that in some documented cases, the identifier in the
last path element (for the entity) itself may be omitted. For example,
the last path element of the key of Mutation.insert may have no
identifier.
A path can never be empty, and a path can have at most 100 elements.
repeated .google.datastore.v1.Key.PathElement path = 2;
| Returns | |
|---|---|
| Type | Description |
List<PathElement> | |
getPathOrBuilder(int index)
public Key.PathElementOrBuilder getPathOrBuilder(int index)The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element identifies a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors.
An entity path is always fully complete: all of the entity's ancestors
are required to be in the path along with the entity identifier itself.
The only exception is that in some documented cases, the identifier in the
last path element (for the entity) itself may be omitted. For example,
the last path element of the key of Mutation.insert may have no
identifier.
A path can never be empty, and a path can have at most 100 elements.
repeated .google.datastore.v1.Key.PathElement path = 2;
| Parameter | |
|---|---|
| Name | Description |
index | int |
| Returns | |
|---|---|
| Type | Description |
Key.PathElementOrBuilder | |
getPathOrBuilderList()
public List<? extends Key.PathElementOrBuilder> getPathOrBuilderList()The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element identifies a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors.
An entity path is always fully complete: all of the entity's ancestors
are required to be in the path along with the entity identifier itself.
The only exception is that in some documented cases, the identifier in the
last path element (for the entity) itself may be omitted. For example,
the last path element of the key of Mutation.insert may have no
identifier.
A path can never be empty, and a path can have at most 100 elements.
repeated .google.datastore.v1.Key.PathElement path = 2;
| Returns | |
|---|---|
| Type | Description |
List<? extends com.google.datastore.v1.Key.PathElementOrBuilder> | |
hasPartitionId()
public boolean hasPartitionId()Entities are partitioned into subsets, currently identified by a project ID and namespace ID. Queries are scoped to a single partition.
.google.datastore.v1.PartitionId partition_id = 1;
| Returns | |
|---|---|
| Type | Description |
boolean | Whether the partitionId field is set. |
internalGetFieldAccessorTable()
protected GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable()| Returns | |
|---|---|
| Type | Description |
FieldAccessorTable | |
isInitialized()
public final boolean isInitialized()| Returns | |
|---|---|
| Type | Description |
boolean | |
mergeFrom(Key other)
public Key.Builder mergeFrom(Key other)| Parameter | |
|---|---|
| Name | Description |
other | Key |
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
mergeFrom(CodedInputStream input, ExtensionRegistryLite extensionRegistry)
public Key.Builder mergeFrom(CodedInputStream input, ExtensionRegistryLite extensionRegistry)| Parameters | |
|---|---|
| Name | Description |
input | CodedInputStream |
extensionRegistry | ExtensionRegistryLite |
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
| Exceptions | |
|---|---|
| Type | Description |
IOException | |
mergeFrom(Message other)
public Key.Builder mergeFrom(Message other)| Parameter | |
|---|---|
| Name | Description |
other | Message |
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
mergePartitionId(PartitionId value)
public Key.Builder mergePartitionId(PartitionId value)Entities are partitioned into subsets, currently identified by a project ID and namespace ID. Queries are scoped to a single partition.
.google.datastore.v1.PartitionId partition_id = 1;
| Parameter | |
|---|---|
| Name | Description |
value | PartitionId |
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
mergeUnknownFields(UnknownFieldSet unknownFields)
public final Key.Builder mergeUnknownFields(UnknownFieldSet unknownFields)| Parameter | |
|---|---|
| Name | Description |
unknownFields | UnknownFieldSet |
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
removePath(int index)
public Key.Builder removePath(int index)The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element identifies a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors.
An entity path is always fully complete: all of the entity's ancestors
are required to be in the path along with the entity identifier itself.
The only exception is that in some documented cases, the identifier in the
last path element (for the entity) itself may be omitted. For example,
the last path element of the key of Mutation.insert may have no
identifier.
A path can never be empty, and a path can have at most 100 elements.
repeated .google.datastore.v1.Key.PathElement path = 2;
| Parameter | |
|---|---|
| Name | Description |
index | int |
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
setField(Descriptors.FieldDescriptor field, Object value)
public Key.Builder setField(Descriptors.FieldDescriptor field, Object value)| Parameters | |
|---|---|
| Name | Description |
field | FieldDescriptor |
value | Object |
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
setPartitionId(PartitionId value)
public Key.Builder setPartitionId(PartitionId value)Entities are partitioned into subsets, currently identified by a project ID and namespace ID. Queries are scoped to a single partition.
.google.datastore.v1.PartitionId partition_id = 1;
| Parameter | |
|---|---|
| Name | Description |
value | PartitionId |
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
setPartitionId(PartitionId.Builder builderForValue)
public Key.Builder setPartitionId(PartitionId.Builder builderForValue)Entities are partitioned into subsets, currently identified by a project ID and namespace ID. Queries are scoped to a single partition.
.google.datastore.v1.PartitionId partition_id = 1;
| Parameter | |
|---|---|
| Name | Description |
builderForValue | PartitionId.Builder |
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
setPath(int index, Key.PathElement value)
public Key.Builder setPath(int index, Key.PathElement value)The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element identifies a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors.
An entity path is always fully complete: all of the entity's ancestors
are required to be in the path along with the entity identifier itself.
The only exception is that in some documented cases, the identifier in the
last path element (for the entity) itself may be omitted. For example,
the last path element of the key of Mutation.insert may have no
identifier.
A path can never be empty, and a path can have at most 100 elements.
repeated .google.datastore.v1.Key.PathElement path = 2;
| Parameters | |
|---|---|
| Name | Description |
index | int |
value | Key.PathElement |
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
setPath(int index, Key.PathElement.Builder builderForValue)
public Key.Builder setPath(int index, Key.PathElement.Builder builderForValue)The entity path. An entity path consists of one or more elements composed of a kind and a string or numerical identifier, which identify entities. The first element identifies a root entity, the second element identifies a child of the root entity, the third element identifies a child of the second entity, and so forth. The entities identified by all prefixes of the path are called the element's ancestors.
An entity path is always fully complete: all of the entity's ancestors
are required to be in the path along with the entity identifier itself.
The only exception is that in some documented cases, the identifier in the
last path element (for the entity) itself may be omitted. For example,
the last path element of the key of Mutation.insert may have no
identifier.
A path can never be empty, and a path can have at most 100 elements.
repeated .google.datastore.v1.Key.PathElement path = 2;
| Parameters | |
|---|---|
| Name | Description |
index | int |
builderForValue | Key.PathElement.Builder |
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
setRepeatedField(Descriptors.FieldDescriptor field, int index, Object value)
public Key.Builder setRepeatedField(Descriptors.FieldDescriptor field, int index, Object value)| Parameters | |
|---|---|
| Name | Description |
field | FieldDescriptor |
index | int |
value | Object |
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |
setUnknownFields(UnknownFieldSet unknownFields)
public final Key.Builder setUnknownFields(UnknownFieldSet unknownFields)| Parameter | |
|---|---|
| Name | Description |
unknownFields | UnknownFieldSet |
| Returns | |
|---|---|
| Type | Description |
Key.Builder | |