public static final class Key.Builder extends GeneratedMessageV3.Builder<Key.Builder> implements KeyOrBuilder
A 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.events.cloud.datastore.v1.Key
Inherited Members
com.google.protobuf.GeneratedMessageV3.Builder.getUnknownFieldSetBuilder()
com.google.protobuf.GeneratedMessageV3.Builder.internalGetMapFieldReflection(int)
com.google.protobuf.GeneratedMessageV3.Builder.internalGetMutableMapFieldReflection(int)
com.google.protobuf.GeneratedMessageV3.Builder.mergeUnknownLengthDelimitedField(int,com.google.protobuf.ByteString)
com.google.protobuf.GeneratedMessageV3.Builder.mergeUnknownVarintField(int,int)
com.google.protobuf.GeneratedMessageV3.Builder.parseUnknownField(com.google.protobuf.CodedInputStream,com.google.protobuf.ExtensionRegistryLite,int)
com.google.protobuf.GeneratedMessageV3.Builder.setUnknownFieldSetBuilder(com.google.protobuf.UnknownFieldSet.Builder)
Static Methods
getDescriptor()
public static final Descriptors.Descriptor getDescriptor()
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.events.cloud.datastore.v1.Key.PathElement path = 2;
| Parameter |
|---|
| Name | Description |
values | Iterable<? extends com.google.events.cloud.datastore.v1.Key.PathElement>
|
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.events.cloud.datastore.v1.Key.PathElement path = 2;
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.events.cloud.datastore.v1.Key.PathElement path = 2;
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.events.cloud.datastore.v1.Key.PathElement path = 2;
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.events.cloud.datastore.v1.Key.PathElement path = 2;
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.events.cloud.datastore.v1.Key.PathElement path = 2;
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.events.cloud.datastore.v1.Key.PathElement path = 2;
| Parameter |
|---|
| Name | Description |
index | int
|
addRepeatedField(Descriptors.FieldDescriptor field, Object value)
public Key.Builder addRepeatedField(Descriptors.FieldDescriptor field, Object value)
Overrides
build()
| Returns |
|---|
| Type | Description |
Key | |
buildPartial()
public Key buildPartial()
| Returns |
|---|
| Type | Description |
Key | |
clear()
public Key.Builder clear()
Overrides
clearField(Descriptors.FieldDescriptor field)
public Key.Builder clearField(Descriptors.FieldDescriptor field)
Overrides
clearOneof(Descriptors.OneofDescriptor oneof)
public Key.Builder clearOneof(Descriptors.OneofDescriptor oneof)
Overrides
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.events.cloud.datastore.v1.PartitionId partition_id = 1;
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.events.cloud.datastore.v1.Key.PathElement path = 2;
clone()
public Key.Builder clone()
Overrides
getDefaultInstanceForType()
public Key getDefaultInstanceForType()
| Returns |
|---|
| Type | Description |
Key | |
getDescriptorForType()
public Descriptors.Descriptor getDescriptorForType()
Overrides
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.events.cloud.datastore.v1.PartitionId partition_id = 1;
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.events.cloud.datastore.v1.PartitionId partition_id = 1;
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.events.cloud.datastore.v1.PartitionId partition_id = 1;
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.events.cloud.datastore.v1.Key.PathElement path = 2;
| Parameter |
|---|
| Name | Description |
index | int
|
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.events.cloud.datastore.v1.Key.PathElement path = 2;
| Parameter |
|---|
| Name | Description |
index | int
|
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.events.cloud.datastore.v1.Key.PathElement path = 2;
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.events.cloud.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.events.cloud.datastore.v1.Key.PathElement path = 2;
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.events.cloud.datastore.v1.Key.PathElement path = 2;
| Parameter |
|---|
| Name | Description |
index | int
|
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.events.cloud.datastore.v1.Key.PathElement path = 2;
| Returns |
|---|
| Type | Description |
List<? extends com.google.events.cloud.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.events.cloud.datastore.v1.PartitionId partition_id = 1;
| Returns |
|---|
| Type | Description |
boolean | Whether the partitionId field is set.
|
internalGetFieldAccessorTable()
protected GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable()
Overrides
isInitialized()
public final boolean isInitialized()
Overrides
mergeFrom(Key other)
public Key.Builder mergeFrom(Key other)
| Parameter |
|---|
| Name | Description |
other | Key
|
public Key.Builder mergeFrom(CodedInputStream input, ExtensionRegistryLite extensionRegistry)
Overrides
mergeFrom(Message other)
public Key.Builder mergeFrom(Message other)
| Parameter |
|---|
| Name | Description |
other | Message
|
Overrides
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.events.cloud.datastore.v1.PartitionId partition_id = 1;
mergeUnknownFields(UnknownFieldSet unknownFields)
public final Key.Builder mergeUnknownFields(UnknownFieldSet unknownFields)
Overrides
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.events.cloud.datastore.v1.Key.PathElement path = 2;
| Parameter |
|---|
| Name | Description |
index | int
|
setField(Descriptors.FieldDescriptor field, Object value)
public Key.Builder setField(Descriptors.FieldDescriptor field, Object value)
Overrides
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.events.cloud.datastore.v1.PartitionId partition_id = 1;
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.events.cloud.datastore.v1.PartitionId partition_id = 1;
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.events.cloud.datastore.v1.Key.PathElement path = 2;
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.events.cloud.datastore.v1.Key.PathElement path = 2;
setRepeatedField(Descriptors.FieldDescriptor field, int index, Object value)
public Key.Builder setRepeatedField(Descriptors.FieldDescriptor field, int index, Object value)
Overrides
setUnknownFields(UnknownFieldSet unknownFields)
public final Key.Builder setUnknownFields(UnknownFieldSet unknownFields)
Overrides
