public static final class PartialResultSet.Builder extends GeneratedMessageV3.Builder<PartialResultSet.Builder> implements PartialResultSetOrBuilder
Partial results from a streaming read or SQL query. Streaming reads and SQL queries better tolerate large result sets, large rows, and large values, but are a little trickier to consume.Protobuf type
google.spanner.v1.PartialResultSet| Modifier and Type | Method and Description |
|---|---|
PartialResultSet.Builder |
addAllValues(Iterable<? extends Value> values)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values.
|
PartialResultSet.Builder |
addRepeatedField(Descriptors.FieldDescriptor field,
Object value) |
PartialResultSet.Builder |
addValues(int index,
Value.Builder builderForValue)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values.
|
PartialResultSet.Builder |
addValues(int index,
Value value)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values.
|
PartialResultSet.Builder |
addValues(Value.Builder builderForValue)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values.
|
PartialResultSet.Builder |
addValues(Value value)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values.
|
Value.Builder |
addValuesBuilder()
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values.
|
Value.Builder |
addValuesBuilder(int index)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values.
|
PartialResultSet |
build() |
PartialResultSet |
buildPartial() |
PartialResultSet.Builder |
clear() |
PartialResultSet.Builder |
clearChunkedValue()
If true, then the final value in [values][google.spanner.v1.PartialResultSet.values] is chunked, and must
be combined with more values from subsequent `PartialResultSet`s
to obtain a complete field value.
|
PartialResultSet.Builder |
clearField(Descriptors.FieldDescriptor field) |
PartialResultSet.Builder |
clearMetadata()
Metadata about the result set, such as row type information.
|
PartialResultSet.Builder |
clearOneof(Descriptors.OneofDescriptor oneof) |
PartialResultSet.Builder |
clearResumeToken()
Streaming calls might be interrupted for a variety of reasons, such
as TCP connection loss.
|
PartialResultSet.Builder |
clearStats()
Query plan and execution statistics for the statement that produced this
streaming result set.
|
PartialResultSet.Builder |
clearValues()
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values.
|
PartialResultSet.Builder |
clone() |
boolean |
getChunkedValue()
If true, then the final value in [values][google.spanner.v1.PartialResultSet.values] is chunked, and must
be combined with more values from subsequent `PartialResultSet`s
to obtain a complete field value.
|
PartialResultSet |
getDefaultInstanceForType() |
static Descriptors.Descriptor |
getDescriptor() |
Descriptors.Descriptor |
getDescriptorForType() |
ResultSetMetadata |
getMetadata()
Metadata about the result set, such as row type information.
|
ResultSetMetadata.Builder |
getMetadataBuilder()
Metadata about the result set, such as row type information.
|
ResultSetMetadataOrBuilder |
getMetadataOrBuilder()
Metadata about the result set, such as row type information.
|
ByteString |
getResumeToken()
Streaming calls might be interrupted for a variety of reasons, such
as TCP connection loss.
|
ResultSetStats |
getStats()
Query plan and execution statistics for the statement that produced this
streaming result set.
|
ResultSetStats.Builder |
getStatsBuilder()
Query plan and execution statistics for the statement that produced this
streaming result set.
|
ResultSetStatsOrBuilder |
getStatsOrBuilder()
Query plan and execution statistics for the statement that produced this
streaming result set.
|
Value |
getValues(int index)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values.
|
Value.Builder |
getValuesBuilder(int index)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values.
|
List<Value.Builder> |
getValuesBuilderList()
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values.
|
int |
getValuesCount()
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values.
|
List<Value> |
getValuesList()
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values.
|
ValueOrBuilder |
getValuesOrBuilder(int index)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values.
|
List<? extends ValueOrBuilder> |
getValuesOrBuilderList()
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values.
|
boolean |
hasMetadata()
Metadata about the result set, such as row type information.
|
boolean |
hasStats()
Query plan and execution statistics for the statement that produced this
streaming result set.
|
protected GeneratedMessageV3.FieldAccessorTable |
internalGetFieldAccessorTable() |
boolean |
isInitialized() |
PartialResultSet.Builder |
mergeFrom(CodedInputStream input,
ExtensionRegistryLite extensionRegistry) |
PartialResultSet.Builder |
mergeFrom(Message other) |
PartialResultSet.Builder |
mergeFrom(PartialResultSet other) |
PartialResultSet.Builder |
mergeMetadata(ResultSetMetadata value)
Metadata about the result set, such as row type information.
|
PartialResultSet.Builder |
mergeStats(ResultSetStats value)
Query plan and execution statistics for the statement that produced this
streaming result set.
|
PartialResultSet.Builder |
mergeUnknownFields(UnknownFieldSet unknownFields) |
PartialResultSet.Builder |
removeValues(int index)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values.
|
PartialResultSet.Builder |
setChunkedValue(boolean value)
If true, then the final value in [values][google.spanner.v1.PartialResultSet.values] is chunked, and must
be combined with more values from subsequent `PartialResultSet`s
to obtain a complete field value.
|
PartialResultSet.Builder |
setField(Descriptors.FieldDescriptor field,
Object value) |
PartialResultSet.Builder |
setMetadata(ResultSetMetadata.Builder builderForValue)
Metadata about the result set, such as row type information.
|
PartialResultSet.Builder |
setMetadata(ResultSetMetadata value)
Metadata about the result set, such as row type information.
|
PartialResultSet.Builder |
setRepeatedField(Descriptors.FieldDescriptor field,
int index,
Object value) |
PartialResultSet.Builder |
setResumeToken(ByteString value)
Streaming calls might be interrupted for a variety of reasons, such
as TCP connection loss.
|
PartialResultSet.Builder |
setStats(ResultSetStats.Builder builderForValue)
Query plan and execution statistics for the statement that produced this
streaming result set.
|
PartialResultSet.Builder |
setStats(ResultSetStats value)
Query plan and execution statistics for the statement that produced this
streaming result set.
|
PartialResultSet.Builder |
setUnknownFields(UnknownFieldSet unknownFields) |
PartialResultSet.Builder |
setValues(int index,
Value.Builder builderForValue)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values.
|
PartialResultSet.Builder |
setValues(int index,
Value value)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values.
|
getAllFields, getField, getFieldBuilder, getOneofFieldDescriptor, getParentForChildren, getRepeatedField, getRepeatedFieldBuilder, getRepeatedFieldCount, getUnknownFields, hasField, hasOneof, internalGetMapField, internalGetMutableMapField, isClean, markClean, newBuilderForField, onBuilt, onChanged, setUnknownFieldsProto3findInitializationErrors, getInitializationErrorString, internalMergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, newUninitializedMessageException, toStringaddAll, addAll, mergeDelimitedFrom, mergeDelimitedFrom, mergeFrom, newUninitializedMessageExceptionequals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, waitfindInitializationErrors, getAllFields, getField, getInitializationErrorString, getOneofFieldDescriptor, getRepeatedField, getRepeatedFieldCount, getUnknownFields, hasField, hasOneofmergeDelimitedFrom, mergeDelimitedFrommergeFrompublic static final Descriptors.Descriptor getDescriptor()
protected GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable()
internalGetFieldAccessorTable in class GeneratedMessageV3.Builder<PartialResultSet.Builder>public PartialResultSet.Builder clear()
clear in interface Message.Builderclear in interface MessageLite.Builderclear in class GeneratedMessageV3.Builder<PartialResultSet.Builder>public Descriptors.Descriptor getDescriptorForType()
getDescriptorForType in interface Message.BuildergetDescriptorForType in interface MessageOrBuildergetDescriptorForType in class GeneratedMessageV3.Builder<PartialResultSet.Builder>public PartialResultSet getDefaultInstanceForType()
getDefaultInstanceForType in interface MessageLiteOrBuildergetDefaultInstanceForType in interface MessageOrBuilderpublic PartialResultSet build()
build in interface Message.Builderbuild in interface MessageLite.Builderpublic PartialResultSet buildPartial()
buildPartial in interface Message.BuilderbuildPartial in interface MessageLite.Builderpublic PartialResultSet.Builder clone()
clone in interface Message.Builderclone in interface MessageLite.Builderclone in class GeneratedMessageV3.Builder<PartialResultSet.Builder>public PartialResultSet.Builder setField(Descriptors.FieldDescriptor field, Object value)
setField in interface Message.BuildersetField in class GeneratedMessageV3.Builder<PartialResultSet.Builder>public PartialResultSet.Builder clearField(Descriptors.FieldDescriptor field)
clearField in interface Message.BuilderclearField in class GeneratedMessageV3.Builder<PartialResultSet.Builder>public PartialResultSet.Builder clearOneof(Descriptors.OneofDescriptor oneof)
clearOneof in interface Message.BuilderclearOneof in class GeneratedMessageV3.Builder<PartialResultSet.Builder>public PartialResultSet.Builder setRepeatedField(Descriptors.FieldDescriptor field, int index, Object value)
setRepeatedField in interface Message.BuildersetRepeatedField in class GeneratedMessageV3.Builder<PartialResultSet.Builder>public PartialResultSet.Builder addRepeatedField(Descriptors.FieldDescriptor field, Object value)
addRepeatedField in interface Message.BuilderaddRepeatedField in class GeneratedMessageV3.Builder<PartialResultSet.Builder>public PartialResultSet.Builder mergeFrom(Message other)
mergeFrom in interface Message.BuildermergeFrom in class AbstractMessage.Builder<PartialResultSet.Builder>public PartialResultSet.Builder mergeFrom(PartialResultSet other)
public final boolean isInitialized()
isInitialized in interface MessageLiteOrBuilderisInitialized in class GeneratedMessageV3.Builder<PartialResultSet.Builder>public PartialResultSet.Builder mergeFrom(CodedInputStream input, ExtensionRegistryLite extensionRegistry) throws IOException
mergeFrom in interface Message.BuildermergeFrom in interface MessageLite.BuildermergeFrom in class AbstractMessage.Builder<PartialResultSet.Builder>IOExceptionpublic boolean hasMetadata()
Metadata about the result set, such as row type information. Only present in the first response.
.google.spanner.v1.ResultSetMetadata metadata = 1;hasMetadata in interface PartialResultSetOrBuilderpublic ResultSetMetadata getMetadata()
Metadata about the result set, such as row type information. Only present in the first response.
.google.spanner.v1.ResultSetMetadata metadata = 1;getMetadata in interface PartialResultSetOrBuilderpublic PartialResultSet.Builder setMetadata(ResultSetMetadata value)
Metadata about the result set, such as row type information. Only present in the first response.
.google.spanner.v1.ResultSetMetadata metadata = 1;public PartialResultSet.Builder setMetadata(ResultSetMetadata.Builder builderForValue)
Metadata about the result set, such as row type information. Only present in the first response.
.google.spanner.v1.ResultSetMetadata metadata = 1;public PartialResultSet.Builder mergeMetadata(ResultSetMetadata value)
Metadata about the result set, such as row type information. Only present in the first response.
.google.spanner.v1.ResultSetMetadata metadata = 1;public PartialResultSet.Builder clearMetadata()
Metadata about the result set, such as row type information. Only present in the first response.
.google.spanner.v1.ResultSetMetadata metadata = 1;public ResultSetMetadata.Builder getMetadataBuilder()
Metadata about the result set, such as row type information. Only present in the first response.
.google.spanner.v1.ResultSetMetadata metadata = 1;public ResultSetMetadataOrBuilder getMetadataOrBuilder()
Metadata about the result set, such as row type information. Only present in the first response.
.google.spanner.v1.ResultSetMetadata metadata = 1;getMetadataOrBuilder in interface PartialResultSetOrBuilderpublic List<Value> getValuesList()
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values. Every N complete values defines a
row, where N is equal to the number of entries in
[metadata.row_type.fields][google.spanner.v1.StructType.fields].
Most values are encoded based on type as described
[here][google.spanner.v1.TypeCode].
It is possible that the last value in values is "chunked",
meaning that the rest of the value is sent in subsequent
`PartialResultSet`(s). This is denoted by the [chunked_value][google.spanner.v1.PartialResultSet.chunked_value]
field. Two or more chunked values can be merged to form a
complete value as follows:
* `bool/number/null`: cannot be chunked
* `string`: concatenate the strings
* `list`: concatenate the lists. If the last element in a list is a
`string`, `list`, or `object`, merge it with the first element in
the next list by applying these rules recursively.
* `object`: concatenate the (field name, field value) pairs. If a
field name is duplicated, then apply these rules recursively
to merge the field values.
Some examples of merging:
# Strings are concatenated.
"foo", "bar" => "foobar"
# Lists of non-strings are concatenated.
[2, 3], [4] => [2, 3, 4]
# Lists are concatenated, but the last and first elements are merged
# because they are strings.
["a", "b"], ["c", "d"] => ["a", "bc", "d"]
# Lists are concatenated, but the last and first elements are merged
# because they are lists. Recursively, the last and first elements
# of the inner lists are merged because they are strings.
["a", ["b", "c"]], [["d"], "e"] => ["a", ["b", "cd"], "e"]
# Non-overlapping object fields are combined.
{"a": "1"}, {"b": "2"} => {"a": "1", "b": 2"}
# Overlapping object fields are merged.
{"a": "1"}, {"a": "2"} => {"a": "12"}
# Examples of merging objects containing lists of strings.
{"a": ["1"]}, {"a": ["2"]} => {"a": ["12"]}
For a more complete example, suppose a streaming SQL query is
yielding a result set whose rows contain a single string
field. The following `PartialResultSet`s might be yielded:
{
"metadata": { ... }
"values": ["Hello", "W"]
"chunked_value": true
"resume_token": "Af65..."
}
{
"values": ["orl"]
"chunked_value": true
"resume_token": "Bqp2..."
}
{
"values": ["d"]
"resume_token": "Zx1B..."
}
This sequence of `PartialResultSet`s encodes two rows, one
containing the field value `"Hello"`, and a second containing the
field value `"World" = "W" + "orl" + "d"`.
repeated .google.protobuf.Value values = 2;getValuesList in interface PartialResultSetOrBuilderpublic int getValuesCount()
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values. Every N complete values defines a
row, where N is equal to the number of entries in
[metadata.row_type.fields][google.spanner.v1.StructType.fields].
Most values are encoded based on type as described
[here][google.spanner.v1.TypeCode].
It is possible that the last value in values is "chunked",
meaning that the rest of the value is sent in subsequent
`PartialResultSet`(s). This is denoted by the [chunked_value][google.spanner.v1.PartialResultSet.chunked_value]
field. Two or more chunked values can be merged to form a
complete value as follows:
* `bool/number/null`: cannot be chunked
* `string`: concatenate the strings
* `list`: concatenate the lists. If the last element in a list is a
`string`, `list`, or `object`, merge it with the first element in
the next list by applying these rules recursively.
* `object`: concatenate the (field name, field value) pairs. If a
field name is duplicated, then apply these rules recursively
to merge the field values.
Some examples of merging:
# Strings are concatenated.
"foo", "bar" => "foobar"
# Lists of non-strings are concatenated.
[2, 3], [4] => [2, 3, 4]
# Lists are concatenated, but the last and first elements are merged
# because they are strings.
["a", "b"], ["c", "d"] => ["a", "bc", "d"]
# Lists are concatenated, but the last and first elements are merged
# because they are lists. Recursively, the last and first elements
# of the inner lists are merged because they are strings.
["a", ["b", "c"]], [["d"], "e"] => ["a", ["b", "cd"], "e"]
# Non-overlapping object fields are combined.
{"a": "1"}, {"b": "2"} => {"a": "1", "b": 2"}
# Overlapping object fields are merged.
{"a": "1"}, {"a": "2"} => {"a": "12"}
# Examples of merging objects containing lists of strings.
{"a": ["1"]}, {"a": ["2"]} => {"a": ["12"]}
For a more complete example, suppose a streaming SQL query is
yielding a result set whose rows contain a single string
field. The following `PartialResultSet`s might be yielded:
{
"metadata": { ... }
"values": ["Hello", "W"]
"chunked_value": true
"resume_token": "Af65..."
}
{
"values": ["orl"]
"chunked_value": true
"resume_token": "Bqp2..."
}
{
"values": ["d"]
"resume_token": "Zx1B..."
}
This sequence of `PartialResultSet`s encodes two rows, one
containing the field value `"Hello"`, and a second containing the
field value `"World" = "W" + "orl" + "d"`.
repeated .google.protobuf.Value values = 2;getValuesCount in interface PartialResultSetOrBuilderpublic Value getValues(int index)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values. Every N complete values defines a
row, where N is equal to the number of entries in
[metadata.row_type.fields][google.spanner.v1.StructType.fields].
Most values are encoded based on type as described
[here][google.spanner.v1.TypeCode].
It is possible that the last value in values is "chunked",
meaning that the rest of the value is sent in subsequent
`PartialResultSet`(s). This is denoted by the [chunked_value][google.spanner.v1.PartialResultSet.chunked_value]
field. Two or more chunked values can be merged to form a
complete value as follows:
* `bool/number/null`: cannot be chunked
* `string`: concatenate the strings
* `list`: concatenate the lists. If the last element in a list is a
`string`, `list`, or `object`, merge it with the first element in
the next list by applying these rules recursively.
* `object`: concatenate the (field name, field value) pairs. If a
field name is duplicated, then apply these rules recursively
to merge the field values.
Some examples of merging:
# Strings are concatenated.
"foo", "bar" => "foobar"
# Lists of non-strings are concatenated.
[2, 3], [4] => [2, 3, 4]
# Lists are concatenated, but the last and first elements are merged
# because they are strings.
["a", "b"], ["c", "d"] => ["a", "bc", "d"]
# Lists are concatenated, but the last and first elements are merged
# because they are lists. Recursively, the last and first elements
# of the inner lists are merged because they are strings.
["a", ["b", "c"]], [["d"], "e"] => ["a", ["b", "cd"], "e"]
# Non-overlapping object fields are combined.
{"a": "1"}, {"b": "2"} => {"a": "1", "b": 2"}
# Overlapping object fields are merged.
{"a": "1"}, {"a": "2"} => {"a": "12"}
# Examples of merging objects containing lists of strings.
{"a": ["1"]}, {"a": ["2"]} => {"a": ["12"]}
For a more complete example, suppose a streaming SQL query is
yielding a result set whose rows contain a single string
field. The following `PartialResultSet`s might be yielded:
{
"metadata": { ... }
"values": ["Hello", "W"]
"chunked_value": true
"resume_token": "Af65..."
}
{
"values": ["orl"]
"chunked_value": true
"resume_token": "Bqp2..."
}
{
"values": ["d"]
"resume_token": "Zx1B..."
}
This sequence of `PartialResultSet`s encodes two rows, one
containing the field value `"Hello"`, and a second containing the
field value `"World" = "W" + "orl" + "d"`.
repeated .google.protobuf.Value values = 2;getValues in interface PartialResultSetOrBuilderpublic PartialResultSet.Builder setValues(int index, Value value)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values. Every N complete values defines a
row, where N is equal to the number of entries in
[metadata.row_type.fields][google.spanner.v1.StructType.fields].
Most values are encoded based on type as described
[here][google.spanner.v1.TypeCode].
It is possible that the last value in values is "chunked",
meaning that the rest of the value is sent in subsequent
`PartialResultSet`(s). This is denoted by the [chunked_value][google.spanner.v1.PartialResultSet.chunked_value]
field. Two or more chunked values can be merged to form a
complete value as follows:
* `bool/number/null`: cannot be chunked
* `string`: concatenate the strings
* `list`: concatenate the lists. If the last element in a list is a
`string`, `list`, or `object`, merge it with the first element in
the next list by applying these rules recursively.
* `object`: concatenate the (field name, field value) pairs. If a
field name is duplicated, then apply these rules recursively
to merge the field values.
Some examples of merging:
# Strings are concatenated.
"foo", "bar" => "foobar"
# Lists of non-strings are concatenated.
[2, 3], [4] => [2, 3, 4]
# Lists are concatenated, but the last and first elements are merged
# because they are strings.
["a", "b"], ["c", "d"] => ["a", "bc", "d"]
# Lists are concatenated, but the last and first elements are merged
# because they are lists. Recursively, the last and first elements
# of the inner lists are merged because they are strings.
["a", ["b", "c"]], [["d"], "e"] => ["a", ["b", "cd"], "e"]
# Non-overlapping object fields are combined.
{"a": "1"}, {"b": "2"} => {"a": "1", "b": 2"}
# Overlapping object fields are merged.
{"a": "1"}, {"a": "2"} => {"a": "12"}
# Examples of merging objects containing lists of strings.
{"a": ["1"]}, {"a": ["2"]} => {"a": ["12"]}
For a more complete example, suppose a streaming SQL query is
yielding a result set whose rows contain a single string
field. The following `PartialResultSet`s might be yielded:
{
"metadata": { ... }
"values": ["Hello", "W"]
"chunked_value": true
"resume_token": "Af65..."
}
{
"values": ["orl"]
"chunked_value": true
"resume_token": "Bqp2..."
}
{
"values": ["d"]
"resume_token": "Zx1B..."
}
This sequence of `PartialResultSet`s encodes two rows, one
containing the field value `"Hello"`, and a second containing the
field value `"World" = "W" + "orl" + "d"`.
repeated .google.protobuf.Value values = 2;public PartialResultSet.Builder setValues(int index, Value.Builder builderForValue)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values. Every N complete values defines a
row, where N is equal to the number of entries in
[metadata.row_type.fields][google.spanner.v1.StructType.fields].
Most values are encoded based on type as described
[here][google.spanner.v1.TypeCode].
It is possible that the last value in values is "chunked",
meaning that the rest of the value is sent in subsequent
`PartialResultSet`(s). This is denoted by the [chunked_value][google.spanner.v1.PartialResultSet.chunked_value]
field. Two or more chunked values can be merged to form a
complete value as follows:
* `bool/number/null`: cannot be chunked
* `string`: concatenate the strings
* `list`: concatenate the lists. If the last element in a list is a
`string`, `list`, or `object`, merge it with the first element in
the next list by applying these rules recursively.
* `object`: concatenate the (field name, field value) pairs. If a
field name is duplicated, then apply these rules recursively
to merge the field values.
Some examples of merging:
# Strings are concatenated.
"foo", "bar" => "foobar"
# Lists of non-strings are concatenated.
[2, 3], [4] => [2, 3, 4]
# Lists are concatenated, but the last and first elements are merged
# because they are strings.
["a", "b"], ["c", "d"] => ["a", "bc", "d"]
# Lists are concatenated, but the last and first elements are merged
# because they are lists. Recursively, the last and first elements
# of the inner lists are merged because they are strings.
["a", ["b", "c"]], [["d"], "e"] => ["a", ["b", "cd"], "e"]
# Non-overlapping object fields are combined.
{"a": "1"}, {"b": "2"} => {"a": "1", "b": 2"}
# Overlapping object fields are merged.
{"a": "1"}, {"a": "2"} => {"a": "12"}
# Examples of merging objects containing lists of strings.
{"a": ["1"]}, {"a": ["2"]} => {"a": ["12"]}
For a more complete example, suppose a streaming SQL query is
yielding a result set whose rows contain a single string
field. The following `PartialResultSet`s might be yielded:
{
"metadata": { ... }
"values": ["Hello", "W"]
"chunked_value": true
"resume_token": "Af65..."
}
{
"values": ["orl"]
"chunked_value": true
"resume_token": "Bqp2..."
}
{
"values": ["d"]
"resume_token": "Zx1B..."
}
This sequence of `PartialResultSet`s encodes two rows, one
containing the field value `"Hello"`, and a second containing the
field value `"World" = "W" + "orl" + "d"`.
repeated .google.protobuf.Value values = 2;public PartialResultSet.Builder addValues(Value value)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values. Every N complete values defines a
row, where N is equal to the number of entries in
[metadata.row_type.fields][google.spanner.v1.StructType.fields].
Most values are encoded based on type as described
[here][google.spanner.v1.TypeCode].
It is possible that the last value in values is "chunked",
meaning that the rest of the value is sent in subsequent
`PartialResultSet`(s). This is denoted by the [chunked_value][google.spanner.v1.PartialResultSet.chunked_value]
field. Two or more chunked values can be merged to form a
complete value as follows:
* `bool/number/null`: cannot be chunked
* `string`: concatenate the strings
* `list`: concatenate the lists. If the last element in a list is a
`string`, `list`, or `object`, merge it with the first element in
the next list by applying these rules recursively.
* `object`: concatenate the (field name, field value) pairs. If a
field name is duplicated, then apply these rules recursively
to merge the field values.
Some examples of merging:
# Strings are concatenated.
"foo", "bar" => "foobar"
# Lists of non-strings are concatenated.
[2, 3], [4] => [2, 3, 4]
# Lists are concatenated, but the last and first elements are merged
# because they are strings.
["a", "b"], ["c", "d"] => ["a", "bc", "d"]
# Lists are concatenated, but the last and first elements are merged
# because they are lists. Recursively, the last and first elements
# of the inner lists are merged because they are strings.
["a", ["b", "c"]], [["d"], "e"] => ["a", ["b", "cd"], "e"]
# Non-overlapping object fields are combined.
{"a": "1"}, {"b": "2"} => {"a": "1", "b": 2"}
# Overlapping object fields are merged.
{"a": "1"}, {"a": "2"} => {"a": "12"}
# Examples of merging objects containing lists of strings.
{"a": ["1"]}, {"a": ["2"]} => {"a": ["12"]}
For a more complete example, suppose a streaming SQL query is
yielding a result set whose rows contain a single string
field. The following `PartialResultSet`s might be yielded:
{
"metadata": { ... }
"values": ["Hello", "W"]
"chunked_value": true
"resume_token": "Af65..."
}
{
"values": ["orl"]
"chunked_value": true
"resume_token": "Bqp2..."
}
{
"values": ["d"]
"resume_token": "Zx1B..."
}
This sequence of `PartialResultSet`s encodes two rows, one
containing the field value `"Hello"`, and a second containing the
field value `"World" = "W" + "orl" + "d"`.
repeated .google.protobuf.Value values = 2;public PartialResultSet.Builder addValues(int index, Value value)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values. Every N complete values defines a
row, where N is equal to the number of entries in
[metadata.row_type.fields][google.spanner.v1.StructType.fields].
Most values are encoded based on type as described
[here][google.spanner.v1.TypeCode].
It is possible that the last value in values is "chunked",
meaning that the rest of the value is sent in subsequent
`PartialResultSet`(s). This is denoted by the [chunked_value][google.spanner.v1.PartialResultSet.chunked_value]
field. Two or more chunked values can be merged to form a
complete value as follows:
* `bool/number/null`: cannot be chunked
* `string`: concatenate the strings
* `list`: concatenate the lists. If the last element in a list is a
`string`, `list`, or `object`, merge it with the first element in
the next list by applying these rules recursively.
* `object`: concatenate the (field name, field value) pairs. If a
field name is duplicated, then apply these rules recursively
to merge the field values.
Some examples of merging:
# Strings are concatenated.
"foo", "bar" => "foobar"
# Lists of non-strings are concatenated.
[2, 3], [4] => [2, 3, 4]
# Lists are concatenated, but the last and first elements are merged
# because they are strings.
["a", "b"], ["c", "d"] => ["a", "bc", "d"]
# Lists are concatenated, but the last and first elements are merged
# because they are lists. Recursively, the last and first elements
# of the inner lists are merged because they are strings.
["a", ["b", "c"]], [["d"], "e"] => ["a", ["b", "cd"], "e"]
# Non-overlapping object fields are combined.
{"a": "1"}, {"b": "2"} => {"a": "1", "b": 2"}
# Overlapping object fields are merged.
{"a": "1"}, {"a": "2"} => {"a": "12"}
# Examples of merging objects containing lists of strings.
{"a": ["1"]}, {"a": ["2"]} => {"a": ["12"]}
For a more complete example, suppose a streaming SQL query is
yielding a result set whose rows contain a single string
field. The following `PartialResultSet`s might be yielded:
{
"metadata": { ... }
"values": ["Hello", "W"]
"chunked_value": true
"resume_token": "Af65..."
}
{
"values": ["orl"]
"chunked_value": true
"resume_token": "Bqp2..."
}
{
"values": ["d"]
"resume_token": "Zx1B..."
}
This sequence of `PartialResultSet`s encodes two rows, one
containing the field value `"Hello"`, and a second containing the
field value `"World" = "W" + "orl" + "d"`.
repeated .google.protobuf.Value values = 2;public PartialResultSet.Builder addValues(Value.Builder builderForValue)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values. Every N complete values defines a
row, where N is equal to the number of entries in
[metadata.row_type.fields][google.spanner.v1.StructType.fields].
Most values are encoded based on type as described
[here][google.spanner.v1.TypeCode].
It is possible that the last value in values is "chunked",
meaning that the rest of the value is sent in subsequent
`PartialResultSet`(s). This is denoted by the [chunked_value][google.spanner.v1.PartialResultSet.chunked_value]
field. Two or more chunked values can be merged to form a
complete value as follows:
* `bool/number/null`: cannot be chunked
* `string`: concatenate the strings
* `list`: concatenate the lists. If the last element in a list is a
`string`, `list`, or `object`, merge it with the first element in
the next list by applying these rules recursively.
* `object`: concatenate the (field name, field value) pairs. If a
field name is duplicated, then apply these rules recursively
to merge the field values.
Some examples of merging:
# Strings are concatenated.
"foo", "bar" => "foobar"
# Lists of non-strings are concatenated.
[2, 3], [4] => [2, 3, 4]
# Lists are concatenated, but the last and first elements are merged
# because they are strings.
["a", "b"], ["c", "d"] => ["a", "bc", "d"]
# Lists are concatenated, but the last and first elements are merged
# because they are lists. Recursively, the last and first elements
# of the inner lists are merged because they are strings.
["a", ["b", "c"]], [["d"], "e"] => ["a", ["b", "cd"], "e"]
# Non-overlapping object fields are combined.
{"a": "1"}, {"b": "2"} => {"a": "1", "b": 2"}
# Overlapping object fields are merged.
{"a": "1"}, {"a": "2"} => {"a": "12"}
# Examples of merging objects containing lists of strings.
{"a": ["1"]}, {"a": ["2"]} => {"a": ["12"]}
For a more complete example, suppose a streaming SQL query is
yielding a result set whose rows contain a single string
field. The following `PartialResultSet`s might be yielded:
{
"metadata": { ... }
"values": ["Hello", "W"]
"chunked_value": true
"resume_token": "Af65..."
}
{
"values": ["orl"]
"chunked_value": true
"resume_token": "Bqp2..."
}
{
"values": ["d"]
"resume_token": "Zx1B..."
}
This sequence of `PartialResultSet`s encodes two rows, one
containing the field value `"Hello"`, and a second containing the
field value `"World" = "W" + "orl" + "d"`.
repeated .google.protobuf.Value values = 2;public PartialResultSet.Builder addValues(int index, Value.Builder builderForValue)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values. Every N complete values defines a
row, where N is equal to the number of entries in
[metadata.row_type.fields][google.spanner.v1.StructType.fields].
Most values are encoded based on type as described
[here][google.spanner.v1.TypeCode].
It is possible that the last value in values is "chunked",
meaning that the rest of the value is sent in subsequent
`PartialResultSet`(s). This is denoted by the [chunked_value][google.spanner.v1.PartialResultSet.chunked_value]
field. Two or more chunked values can be merged to form a
complete value as follows:
* `bool/number/null`: cannot be chunked
* `string`: concatenate the strings
* `list`: concatenate the lists. If the last element in a list is a
`string`, `list`, or `object`, merge it with the first element in
the next list by applying these rules recursively.
* `object`: concatenate the (field name, field value) pairs. If a
field name is duplicated, then apply these rules recursively
to merge the field values.
Some examples of merging:
# Strings are concatenated.
"foo", "bar" => "foobar"
# Lists of non-strings are concatenated.
[2, 3], [4] => [2, 3, 4]
# Lists are concatenated, but the last and first elements are merged
# because they are strings.
["a", "b"], ["c", "d"] => ["a", "bc", "d"]
# Lists are concatenated, but the last and first elements are merged
# because they are lists. Recursively, the last and first elements
# of the inner lists are merged because they are strings.
["a", ["b", "c"]], [["d"], "e"] => ["a", ["b", "cd"], "e"]
# Non-overlapping object fields are combined.
{"a": "1"}, {"b": "2"} => {"a": "1", "b": 2"}
# Overlapping object fields are merged.
{"a": "1"}, {"a": "2"} => {"a": "12"}
# Examples of merging objects containing lists of strings.
{"a": ["1"]}, {"a": ["2"]} => {"a": ["12"]}
For a more complete example, suppose a streaming SQL query is
yielding a result set whose rows contain a single string
field. The following `PartialResultSet`s might be yielded:
{
"metadata": { ... }
"values": ["Hello", "W"]
"chunked_value": true
"resume_token": "Af65..."
}
{
"values": ["orl"]
"chunked_value": true
"resume_token": "Bqp2..."
}
{
"values": ["d"]
"resume_token": "Zx1B..."
}
This sequence of `PartialResultSet`s encodes two rows, one
containing the field value `"Hello"`, and a second containing the
field value `"World" = "W" + "orl" + "d"`.
repeated .google.protobuf.Value values = 2;public PartialResultSet.Builder addAllValues(Iterable<? extends Value> values)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values. Every N complete values defines a
row, where N is equal to the number of entries in
[metadata.row_type.fields][google.spanner.v1.StructType.fields].
Most values are encoded based on type as described
[here][google.spanner.v1.TypeCode].
It is possible that the last value in values is "chunked",
meaning that the rest of the value is sent in subsequent
`PartialResultSet`(s). This is denoted by the [chunked_value][google.spanner.v1.PartialResultSet.chunked_value]
field. Two or more chunked values can be merged to form a
complete value as follows:
* `bool/number/null`: cannot be chunked
* `string`: concatenate the strings
* `list`: concatenate the lists. If the last element in a list is a
`string`, `list`, or `object`, merge it with the first element in
the next list by applying these rules recursively.
* `object`: concatenate the (field name, field value) pairs. If a
field name is duplicated, then apply these rules recursively
to merge the field values.
Some examples of merging:
# Strings are concatenated.
"foo", "bar" => "foobar"
# Lists of non-strings are concatenated.
[2, 3], [4] => [2, 3, 4]
# Lists are concatenated, but the last and first elements are merged
# because they are strings.
["a", "b"], ["c", "d"] => ["a", "bc", "d"]
# Lists are concatenated, but the last and first elements are merged
# because they are lists. Recursively, the last and first elements
# of the inner lists are merged because they are strings.
["a", ["b", "c"]], [["d"], "e"] => ["a", ["b", "cd"], "e"]
# Non-overlapping object fields are combined.
{"a": "1"}, {"b": "2"} => {"a": "1", "b": 2"}
# Overlapping object fields are merged.
{"a": "1"}, {"a": "2"} => {"a": "12"}
# Examples of merging objects containing lists of strings.
{"a": ["1"]}, {"a": ["2"]} => {"a": ["12"]}
For a more complete example, suppose a streaming SQL query is
yielding a result set whose rows contain a single string
field. The following `PartialResultSet`s might be yielded:
{
"metadata": { ... }
"values": ["Hello", "W"]
"chunked_value": true
"resume_token": "Af65..."
}
{
"values": ["orl"]
"chunked_value": true
"resume_token": "Bqp2..."
}
{
"values": ["d"]
"resume_token": "Zx1B..."
}
This sequence of `PartialResultSet`s encodes two rows, one
containing the field value `"Hello"`, and a second containing the
field value `"World" = "W" + "orl" + "d"`.
repeated .google.protobuf.Value values = 2;public PartialResultSet.Builder clearValues()
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values. Every N complete values defines a
row, where N is equal to the number of entries in
[metadata.row_type.fields][google.spanner.v1.StructType.fields].
Most values are encoded based on type as described
[here][google.spanner.v1.TypeCode].
It is possible that the last value in values is "chunked",
meaning that the rest of the value is sent in subsequent
`PartialResultSet`(s). This is denoted by the [chunked_value][google.spanner.v1.PartialResultSet.chunked_value]
field. Two or more chunked values can be merged to form a
complete value as follows:
* `bool/number/null`: cannot be chunked
* `string`: concatenate the strings
* `list`: concatenate the lists. If the last element in a list is a
`string`, `list`, or `object`, merge it with the first element in
the next list by applying these rules recursively.
* `object`: concatenate the (field name, field value) pairs. If a
field name is duplicated, then apply these rules recursively
to merge the field values.
Some examples of merging:
# Strings are concatenated.
"foo", "bar" => "foobar"
# Lists of non-strings are concatenated.
[2, 3], [4] => [2, 3, 4]
# Lists are concatenated, but the last and first elements are merged
# because they are strings.
["a", "b"], ["c", "d"] => ["a", "bc", "d"]
# Lists are concatenated, but the last and first elements are merged
# because they are lists. Recursively, the last and first elements
# of the inner lists are merged because they are strings.
["a", ["b", "c"]], [["d"], "e"] => ["a", ["b", "cd"], "e"]
# Non-overlapping object fields are combined.
{"a": "1"}, {"b": "2"} => {"a": "1", "b": 2"}
# Overlapping object fields are merged.
{"a": "1"}, {"a": "2"} => {"a": "12"}
# Examples of merging objects containing lists of strings.
{"a": ["1"]}, {"a": ["2"]} => {"a": ["12"]}
For a more complete example, suppose a streaming SQL query is
yielding a result set whose rows contain a single string
field. The following `PartialResultSet`s might be yielded:
{
"metadata": { ... }
"values": ["Hello", "W"]
"chunked_value": true
"resume_token": "Af65..."
}
{
"values": ["orl"]
"chunked_value": true
"resume_token": "Bqp2..."
}
{
"values": ["d"]
"resume_token": "Zx1B..."
}
This sequence of `PartialResultSet`s encodes two rows, one
containing the field value `"Hello"`, and a second containing the
field value `"World" = "W" + "orl" + "d"`.
repeated .google.protobuf.Value values = 2;public PartialResultSet.Builder removeValues(int index)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values. Every N complete values defines a
row, where N is equal to the number of entries in
[metadata.row_type.fields][google.spanner.v1.StructType.fields].
Most values are encoded based on type as described
[here][google.spanner.v1.TypeCode].
It is possible that the last value in values is "chunked",
meaning that the rest of the value is sent in subsequent
`PartialResultSet`(s). This is denoted by the [chunked_value][google.spanner.v1.PartialResultSet.chunked_value]
field. Two or more chunked values can be merged to form a
complete value as follows:
* `bool/number/null`: cannot be chunked
* `string`: concatenate the strings
* `list`: concatenate the lists. If the last element in a list is a
`string`, `list`, or `object`, merge it with the first element in
the next list by applying these rules recursively.
* `object`: concatenate the (field name, field value) pairs. If a
field name is duplicated, then apply these rules recursively
to merge the field values.
Some examples of merging:
# Strings are concatenated.
"foo", "bar" => "foobar"
# Lists of non-strings are concatenated.
[2, 3], [4] => [2, 3, 4]
# Lists are concatenated, but the last and first elements are merged
# because they are strings.
["a", "b"], ["c", "d"] => ["a", "bc", "d"]
# Lists are concatenated, but the last and first elements are merged
# because they are lists. Recursively, the last and first elements
# of the inner lists are merged because they are strings.
["a", ["b", "c"]], [["d"], "e"] => ["a", ["b", "cd"], "e"]
# Non-overlapping object fields are combined.
{"a": "1"}, {"b": "2"} => {"a": "1", "b": 2"}
# Overlapping object fields are merged.
{"a": "1"}, {"a": "2"} => {"a": "12"}
# Examples of merging objects containing lists of strings.
{"a": ["1"]}, {"a": ["2"]} => {"a": ["12"]}
For a more complete example, suppose a streaming SQL query is
yielding a result set whose rows contain a single string
field. The following `PartialResultSet`s might be yielded:
{
"metadata": { ... }
"values": ["Hello", "W"]
"chunked_value": true
"resume_token": "Af65..."
}
{
"values": ["orl"]
"chunked_value": true
"resume_token": "Bqp2..."
}
{
"values": ["d"]
"resume_token": "Zx1B..."
}
This sequence of `PartialResultSet`s encodes two rows, one
containing the field value `"Hello"`, and a second containing the
field value `"World" = "W" + "orl" + "d"`.
repeated .google.protobuf.Value values = 2;public Value.Builder getValuesBuilder(int index)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values. Every N complete values defines a
row, where N is equal to the number of entries in
[metadata.row_type.fields][google.spanner.v1.StructType.fields].
Most values are encoded based on type as described
[here][google.spanner.v1.TypeCode].
It is possible that the last value in values is "chunked",
meaning that the rest of the value is sent in subsequent
`PartialResultSet`(s). This is denoted by the [chunked_value][google.spanner.v1.PartialResultSet.chunked_value]
field. Two or more chunked values can be merged to form a
complete value as follows:
* `bool/number/null`: cannot be chunked
* `string`: concatenate the strings
* `list`: concatenate the lists. If the last element in a list is a
`string`, `list`, or `object`, merge it with the first element in
the next list by applying these rules recursively.
* `object`: concatenate the (field name, field value) pairs. If a
field name is duplicated, then apply these rules recursively
to merge the field values.
Some examples of merging:
# Strings are concatenated.
"foo", "bar" => "foobar"
# Lists of non-strings are concatenated.
[2, 3], [4] => [2, 3, 4]
# Lists are concatenated, but the last and first elements are merged
# because they are strings.
["a", "b"], ["c", "d"] => ["a", "bc", "d"]
# Lists are concatenated, but the last and first elements are merged
# because they are lists. Recursively, the last and first elements
# of the inner lists are merged because they are strings.
["a", ["b", "c"]], [["d"], "e"] => ["a", ["b", "cd"], "e"]
# Non-overlapping object fields are combined.
{"a": "1"}, {"b": "2"} => {"a": "1", "b": 2"}
# Overlapping object fields are merged.
{"a": "1"}, {"a": "2"} => {"a": "12"}
# Examples of merging objects containing lists of strings.
{"a": ["1"]}, {"a": ["2"]} => {"a": ["12"]}
For a more complete example, suppose a streaming SQL query is
yielding a result set whose rows contain a single string
field. The following `PartialResultSet`s might be yielded:
{
"metadata": { ... }
"values": ["Hello", "W"]
"chunked_value": true
"resume_token": "Af65..."
}
{
"values": ["orl"]
"chunked_value": true
"resume_token": "Bqp2..."
}
{
"values": ["d"]
"resume_token": "Zx1B..."
}
This sequence of `PartialResultSet`s encodes two rows, one
containing the field value `"Hello"`, and a second containing the
field value `"World" = "W" + "orl" + "d"`.
repeated .google.protobuf.Value values = 2;public ValueOrBuilder getValuesOrBuilder(int index)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values. Every N complete values defines a
row, where N is equal to the number of entries in
[metadata.row_type.fields][google.spanner.v1.StructType.fields].
Most values are encoded based on type as described
[here][google.spanner.v1.TypeCode].
It is possible that the last value in values is "chunked",
meaning that the rest of the value is sent in subsequent
`PartialResultSet`(s). This is denoted by the [chunked_value][google.spanner.v1.PartialResultSet.chunked_value]
field. Two or more chunked values can be merged to form a
complete value as follows:
* `bool/number/null`: cannot be chunked
* `string`: concatenate the strings
* `list`: concatenate the lists. If the last element in a list is a
`string`, `list`, or `object`, merge it with the first element in
the next list by applying these rules recursively.
* `object`: concatenate the (field name, field value) pairs. If a
field name is duplicated, then apply these rules recursively
to merge the field values.
Some examples of merging:
# Strings are concatenated.
"foo", "bar" => "foobar"
# Lists of non-strings are concatenated.
[2, 3], [4] => [2, 3, 4]
# Lists are concatenated, but the last and first elements are merged
# because they are strings.
["a", "b"], ["c", "d"] => ["a", "bc", "d"]
# Lists are concatenated, but the last and first elements are merged
# because they are lists. Recursively, the last and first elements
# of the inner lists are merged because they are strings.
["a", ["b", "c"]], [["d"], "e"] => ["a", ["b", "cd"], "e"]
# Non-overlapping object fields are combined.
{"a": "1"}, {"b": "2"} => {"a": "1", "b": 2"}
# Overlapping object fields are merged.
{"a": "1"}, {"a": "2"} => {"a": "12"}
# Examples of merging objects containing lists of strings.
{"a": ["1"]}, {"a": ["2"]} => {"a": ["12"]}
For a more complete example, suppose a streaming SQL query is
yielding a result set whose rows contain a single string
field. The following `PartialResultSet`s might be yielded:
{
"metadata": { ... }
"values": ["Hello", "W"]
"chunked_value": true
"resume_token": "Af65..."
}
{
"values": ["orl"]
"chunked_value": true
"resume_token": "Bqp2..."
}
{
"values": ["d"]
"resume_token": "Zx1B..."
}
This sequence of `PartialResultSet`s encodes two rows, one
containing the field value `"Hello"`, and a second containing the
field value `"World" = "W" + "orl" + "d"`.
repeated .google.protobuf.Value values = 2;getValuesOrBuilder in interface PartialResultSetOrBuilderpublic List<? extends ValueOrBuilder> getValuesOrBuilderList()
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values. Every N complete values defines a
row, where N is equal to the number of entries in
[metadata.row_type.fields][google.spanner.v1.StructType.fields].
Most values are encoded based on type as described
[here][google.spanner.v1.TypeCode].
It is possible that the last value in values is "chunked",
meaning that the rest of the value is sent in subsequent
`PartialResultSet`(s). This is denoted by the [chunked_value][google.spanner.v1.PartialResultSet.chunked_value]
field. Two or more chunked values can be merged to form a
complete value as follows:
* `bool/number/null`: cannot be chunked
* `string`: concatenate the strings
* `list`: concatenate the lists. If the last element in a list is a
`string`, `list`, or `object`, merge it with the first element in
the next list by applying these rules recursively.
* `object`: concatenate the (field name, field value) pairs. If a
field name is duplicated, then apply these rules recursively
to merge the field values.
Some examples of merging:
# Strings are concatenated.
"foo", "bar" => "foobar"
# Lists of non-strings are concatenated.
[2, 3], [4] => [2, 3, 4]
# Lists are concatenated, but the last and first elements are merged
# because they are strings.
["a", "b"], ["c", "d"] => ["a", "bc", "d"]
# Lists are concatenated, but the last and first elements are merged
# because they are lists. Recursively, the last and first elements
# of the inner lists are merged because they are strings.
["a", ["b", "c"]], [["d"], "e"] => ["a", ["b", "cd"], "e"]
# Non-overlapping object fields are combined.
{"a": "1"}, {"b": "2"} => {"a": "1", "b": 2"}
# Overlapping object fields are merged.
{"a": "1"}, {"a": "2"} => {"a": "12"}
# Examples of merging objects containing lists of strings.
{"a": ["1"]}, {"a": ["2"]} => {"a": ["12"]}
For a more complete example, suppose a streaming SQL query is
yielding a result set whose rows contain a single string
field. The following `PartialResultSet`s might be yielded:
{
"metadata": { ... }
"values": ["Hello", "W"]
"chunked_value": true
"resume_token": "Af65..."
}
{
"values": ["orl"]
"chunked_value": true
"resume_token": "Bqp2..."
}
{
"values": ["d"]
"resume_token": "Zx1B..."
}
This sequence of `PartialResultSet`s encodes two rows, one
containing the field value `"Hello"`, and a second containing the
field value `"World" = "W" + "orl" + "d"`.
repeated .google.protobuf.Value values = 2;getValuesOrBuilderList in interface PartialResultSetOrBuilderpublic Value.Builder addValuesBuilder()
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values. Every N complete values defines a
row, where N is equal to the number of entries in
[metadata.row_type.fields][google.spanner.v1.StructType.fields].
Most values are encoded based on type as described
[here][google.spanner.v1.TypeCode].
It is possible that the last value in values is "chunked",
meaning that the rest of the value is sent in subsequent
`PartialResultSet`(s). This is denoted by the [chunked_value][google.spanner.v1.PartialResultSet.chunked_value]
field. Two or more chunked values can be merged to form a
complete value as follows:
* `bool/number/null`: cannot be chunked
* `string`: concatenate the strings
* `list`: concatenate the lists. If the last element in a list is a
`string`, `list`, or `object`, merge it with the first element in
the next list by applying these rules recursively.
* `object`: concatenate the (field name, field value) pairs. If a
field name is duplicated, then apply these rules recursively
to merge the field values.
Some examples of merging:
# Strings are concatenated.
"foo", "bar" => "foobar"
# Lists of non-strings are concatenated.
[2, 3], [4] => [2, 3, 4]
# Lists are concatenated, but the last and first elements are merged
# because they are strings.
["a", "b"], ["c", "d"] => ["a", "bc", "d"]
# Lists are concatenated, but the last and first elements are merged
# because they are lists. Recursively, the last and first elements
# of the inner lists are merged because they are strings.
["a", ["b", "c"]], [["d"], "e"] => ["a", ["b", "cd"], "e"]
# Non-overlapping object fields are combined.
{"a": "1"}, {"b": "2"} => {"a": "1", "b": 2"}
# Overlapping object fields are merged.
{"a": "1"}, {"a": "2"} => {"a": "12"}
# Examples of merging objects containing lists of strings.
{"a": ["1"]}, {"a": ["2"]} => {"a": ["12"]}
For a more complete example, suppose a streaming SQL query is
yielding a result set whose rows contain a single string
field. The following `PartialResultSet`s might be yielded:
{
"metadata": { ... }
"values": ["Hello", "W"]
"chunked_value": true
"resume_token": "Af65..."
}
{
"values": ["orl"]
"chunked_value": true
"resume_token": "Bqp2..."
}
{
"values": ["d"]
"resume_token": "Zx1B..."
}
This sequence of `PartialResultSet`s encodes two rows, one
containing the field value `"Hello"`, and a second containing the
field value `"World" = "W" + "orl" + "d"`.
repeated .google.protobuf.Value values = 2;public Value.Builder addValuesBuilder(int index)
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values. Every N complete values defines a
row, where N is equal to the number of entries in
[metadata.row_type.fields][google.spanner.v1.StructType.fields].
Most values are encoded based on type as described
[here][google.spanner.v1.TypeCode].
It is possible that the last value in values is "chunked",
meaning that the rest of the value is sent in subsequent
`PartialResultSet`(s). This is denoted by the [chunked_value][google.spanner.v1.PartialResultSet.chunked_value]
field. Two or more chunked values can be merged to form a
complete value as follows:
* `bool/number/null`: cannot be chunked
* `string`: concatenate the strings
* `list`: concatenate the lists. If the last element in a list is a
`string`, `list`, or `object`, merge it with the first element in
the next list by applying these rules recursively.
* `object`: concatenate the (field name, field value) pairs. If a
field name is duplicated, then apply these rules recursively
to merge the field values.
Some examples of merging:
# Strings are concatenated.
"foo", "bar" => "foobar"
# Lists of non-strings are concatenated.
[2, 3], [4] => [2, 3, 4]
# Lists are concatenated, but the last and first elements are merged
# because they are strings.
["a", "b"], ["c", "d"] => ["a", "bc", "d"]
# Lists are concatenated, but the last and first elements are merged
# because they are lists. Recursively, the last and first elements
# of the inner lists are merged because they are strings.
["a", ["b", "c"]], [["d"], "e"] => ["a", ["b", "cd"], "e"]
# Non-overlapping object fields are combined.
{"a": "1"}, {"b": "2"} => {"a": "1", "b": 2"}
# Overlapping object fields are merged.
{"a": "1"}, {"a": "2"} => {"a": "12"}
# Examples of merging objects containing lists of strings.
{"a": ["1"]}, {"a": ["2"]} => {"a": ["12"]}
For a more complete example, suppose a streaming SQL query is
yielding a result set whose rows contain a single string
field. The following `PartialResultSet`s might be yielded:
{
"metadata": { ... }
"values": ["Hello", "W"]
"chunked_value": true
"resume_token": "Af65..."
}
{
"values": ["orl"]
"chunked_value": true
"resume_token": "Bqp2..."
}
{
"values": ["d"]
"resume_token": "Zx1B..."
}
This sequence of `PartialResultSet`s encodes two rows, one
containing the field value `"Hello"`, and a second containing the
field value `"World" = "W" + "orl" + "d"`.
repeated .google.protobuf.Value values = 2;public List<Value.Builder> getValuesBuilderList()
A streamed result set consists of a stream of values, which might
be split into many `PartialResultSet` messages to accommodate
large rows and/or large values. Every N complete values defines a
row, where N is equal to the number of entries in
[metadata.row_type.fields][google.spanner.v1.StructType.fields].
Most values are encoded based on type as described
[here][google.spanner.v1.TypeCode].
It is possible that the last value in values is "chunked",
meaning that the rest of the value is sent in subsequent
`PartialResultSet`(s). This is denoted by the [chunked_value][google.spanner.v1.PartialResultSet.chunked_value]
field. Two or more chunked values can be merged to form a
complete value as follows:
* `bool/number/null`: cannot be chunked
* `string`: concatenate the strings
* `list`: concatenate the lists. If the last element in a list is a
`string`, `list`, or `object`, merge it with the first element in
the next list by applying these rules recursively.
* `object`: concatenate the (field name, field value) pairs. If a
field name is duplicated, then apply these rules recursively
to merge the field values.
Some examples of merging:
# Strings are concatenated.
"foo", "bar" => "foobar"
# Lists of non-strings are concatenated.
[2, 3], [4] => [2, 3, 4]
# Lists are concatenated, but the last and first elements are merged
# because they are strings.
["a", "b"], ["c", "d"] => ["a", "bc", "d"]
# Lists are concatenated, but the last and first elements are merged
# because they are lists. Recursively, the last and first elements
# of the inner lists are merged because they are strings.
["a", ["b", "c"]], [["d"], "e"] => ["a", ["b", "cd"], "e"]
# Non-overlapping object fields are combined.
{"a": "1"}, {"b": "2"} => {"a": "1", "b": 2"}
# Overlapping object fields are merged.
{"a": "1"}, {"a": "2"} => {"a": "12"}
# Examples of merging objects containing lists of strings.
{"a": ["1"]}, {"a": ["2"]} => {"a": ["12"]}
For a more complete example, suppose a streaming SQL query is
yielding a result set whose rows contain a single string
field. The following `PartialResultSet`s might be yielded:
{
"metadata": { ... }
"values": ["Hello", "W"]
"chunked_value": true
"resume_token": "Af65..."
}
{
"values": ["orl"]
"chunked_value": true
"resume_token": "Bqp2..."
}
{
"values": ["d"]
"resume_token": "Zx1B..."
}
This sequence of `PartialResultSet`s encodes two rows, one
containing the field value `"Hello"`, and a second containing the
field value `"World" = "W" + "orl" + "d"`.
repeated .google.protobuf.Value values = 2;public boolean getChunkedValue()
If true, then the final value in [values][google.spanner.v1.PartialResultSet.values] is chunked, and must be combined with more values from subsequent `PartialResultSet`s to obtain a complete field value.
bool chunked_value = 3;getChunkedValue in interface PartialResultSetOrBuilderpublic PartialResultSet.Builder setChunkedValue(boolean value)
If true, then the final value in [values][google.spanner.v1.PartialResultSet.values] is chunked, and must be combined with more values from subsequent `PartialResultSet`s to obtain a complete field value.
bool chunked_value = 3;value - The chunkedValue to set.public PartialResultSet.Builder clearChunkedValue()
If true, then the final value in [values][google.spanner.v1.PartialResultSet.values] is chunked, and must be combined with more values from subsequent `PartialResultSet`s to obtain a complete field value.
bool chunked_value = 3;public ByteString getResumeToken()
Streaming calls might be interrupted for a variety of reasons, such as TCP connection loss. If this occurs, the stream of results can be resumed by re-sending the original request and including `resume_token`. Note that executing any other transaction in the same session invalidates the token.
bytes resume_token = 4;getResumeToken in interface PartialResultSetOrBuilderpublic PartialResultSet.Builder setResumeToken(ByteString value)
Streaming calls might be interrupted for a variety of reasons, such as TCP connection loss. If this occurs, the stream of results can be resumed by re-sending the original request and including `resume_token`. Note that executing any other transaction in the same session invalidates the token.
bytes resume_token = 4;value - The resumeToken to set.public PartialResultSet.Builder clearResumeToken()
Streaming calls might be interrupted for a variety of reasons, such as TCP connection loss. If this occurs, the stream of results can be resumed by re-sending the original request and including `resume_token`. Note that executing any other transaction in the same session invalidates the token.
bytes resume_token = 4;public boolean hasStats()
Query plan and execution statistics for the statement that produced this streaming result set. These can be requested by setting [ExecuteSqlRequest.query_mode][google.spanner.v1.ExecuteSqlRequest.query_mode] and are sent only once with the last response in the stream. This field will also be present in the last response for DML statements.
.google.spanner.v1.ResultSetStats stats = 5;hasStats in interface PartialResultSetOrBuilderpublic ResultSetStats getStats()
Query plan and execution statistics for the statement that produced this streaming result set. These can be requested by setting [ExecuteSqlRequest.query_mode][google.spanner.v1.ExecuteSqlRequest.query_mode] and are sent only once with the last response in the stream. This field will also be present in the last response for DML statements.
.google.spanner.v1.ResultSetStats stats = 5;getStats in interface PartialResultSetOrBuilderpublic PartialResultSet.Builder setStats(ResultSetStats value)
Query plan and execution statistics for the statement that produced this streaming result set. These can be requested by setting [ExecuteSqlRequest.query_mode][google.spanner.v1.ExecuteSqlRequest.query_mode] and are sent only once with the last response in the stream. This field will also be present in the last response for DML statements.
.google.spanner.v1.ResultSetStats stats = 5;public PartialResultSet.Builder setStats(ResultSetStats.Builder builderForValue)
Query plan and execution statistics for the statement that produced this streaming result set. These can be requested by setting [ExecuteSqlRequest.query_mode][google.spanner.v1.ExecuteSqlRequest.query_mode] and are sent only once with the last response in the stream. This field will also be present in the last response for DML statements.
.google.spanner.v1.ResultSetStats stats = 5;public PartialResultSet.Builder mergeStats(ResultSetStats value)
Query plan and execution statistics for the statement that produced this streaming result set. These can be requested by setting [ExecuteSqlRequest.query_mode][google.spanner.v1.ExecuteSqlRequest.query_mode] and are sent only once with the last response in the stream. This field will also be present in the last response for DML statements.
.google.spanner.v1.ResultSetStats stats = 5;public PartialResultSet.Builder clearStats()
Query plan and execution statistics for the statement that produced this streaming result set. These can be requested by setting [ExecuteSqlRequest.query_mode][google.spanner.v1.ExecuteSqlRequest.query_mode] and are sent only once with the last response in the stream. This field will also be present in the last response for DML statements.
.google.spanner.v1.ResultSetStats stats = 5;public ResultSetStats.Builder getStatsBuilder()
Query plan and execution statistics for the statement that produced this streaming result set. These can be requested by setting [ExecuteSqlRequest.query_mode][google.spanner.v1.ExecuteSqlRequest.query_mode] and are sent only once with the last response in the stream. This field will also be present in the last response for DML statements.
.google.spanner.v1.ResultSetStats stats = 5;public ResultSetStatsOrBuilder getStatsOrBuilder()
Query plan and execution statistics for the statement that produced this streaming result set. These can be requested by setting [ExecuteSqlRequest.query_mode][google.spanner.v1.ExecuteSqlRequest.query_mode] and are sent only once with the last response in the stream. This field will also be present in the last response for DML statements.
.google.spanner.v1.ResultSetStats stats = 5;getStatsOrBuilder in interface PartialResultSetOrBuilderpublic final PartialResultSet.Builder setUnknownFields(UnknownFieldSet unknownFields)
setUnknownFields in interface Message.BuildersetUnknownFields in class GeneratedMessageV3.Builder<PartialResultSet.Builder>public final PartialResultSet.Builder mergeUnknownFields(UnknownFieldSet unknownFields)
mergeUnknownFields in interface Message.BuildermergeUnknownFields in class GeneratedMessageV3.Builder<PartialResultSet.Builder>Copyright © 2022 Google LLC. All rights reserved.