Package com.google.spanner.v1

Class PartialResultSet.Builder

  • All Implemented Interfaces:
    com.google.protobuf.Message.Builder, com.google.protobuf.MessageLite.Builder, com.google.protobuf.MessageLiteOrBuilder, com.google.protobuf.MessageOrBuilder, PartialResultSetOrBuilder, Cloneable
    Enclosing class:
    PartialResultSet
    public static final class PartialResultSet.Builder
extends com.google.protobuf.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

    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      PartialResultSet.Builder addAllValues​(Iterable<? extends com.google.protobuf.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​(com.google.protobuf.Descriptors.FieldDescriptor field, Object value)  
      PartialResultSet.Builder addValues​(int index, com.google.protobuf.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​(int index, com.google.protobuf.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​(com.google.protobuf.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​(com.google.protobuf.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.
      com.google.protobuf.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.
      com.google.protobuf.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​(com.google.protobuf.Descriptors.FieldDescriptor field)  
      PartialResultSet.Builder clearMetadata()
      Metadata about the result set, such as row type information.
      PartialResultSet.Builder clearOneof​(com.google.protobuf.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 com.google.protobuf.Descriptors.Descriptor getDescriptor()  
      com.google.protobuf.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.
      com.google.protobuf.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.
      com.google.protobuf.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.
      com.google.protobuf.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<com.google.protobuf.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<com.google.protobuf.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.
      com.google.protobuf.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 com.google.protobuf.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 com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable()  
      boolean isInitialized()  
      PartialResultSet.Builder mergeFrom​(com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)  
      PartialResultSet.Builder mergeFrom​(com.google.protobuf.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​(com.google.protobuf.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​(com.google.protobuf.Descriptors.FieldDescriptor field, Object value)  
      PartialResultSet.Builder setMetadata​(ResultSetMetadata value)
      Metadata about the result set, such as row type information.
      PartialResultSet.Builder setMetadata​(ResultSetMetadata.Builder builderForValue)
      Metadata about the result set, such as row type information.
      PartialResultSet.Builder setRepeatedField​(com.google.protobuf.Descriptors.FieldDescriptor field, int index, Object value)  
      PartialResultSet.Builder setResumeToken​(com.google.protobuf.ByteString value)
      Streaming calls might be interrupted for a variety of reasons, such as TCP connection loss.
      PartialResultSet.Builder setStats​(ResultSetStats value)
      Query plan and execution statistics for the statement that produced this streaming result set.
      PartialResultSet.Builder setStats​(ResultSetStats.Builder builderForValue)
      Query plan and execution statistics for the statement that produced this streaming result set.
      PartialResultSet.Builder setUnknownFields​(com.google.protobuf.UnknownFieldSet unknownFields)  
      PartialResultSet.Builder setValues​(int index, com.google.protobuf.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 setValues​(int index, com.google.protobuf.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.

      • Methods inherited from class com.google.protobuf.GeneratedMessageV3.Builder

        getAllFields, getField, getFieldBuilder, getOneofFieldDescriptor, getParentForChildren, getRepeatedField, getRepeatedFieldBuilder, getRepeatedFieldCount, getUnknownFields, getUnknownFieldSetBuilder, hasField, hasOneof, internalGetMapField, internalGetMutableMapField, isClean, markClean, mergeUnknownLengthDelimitedField, mergeUnknownVarintField, newBuilderForField, onBuilt, onChanged, parseUnknownField, setUnknownFieldSetBuilder, setUnknownFieldsProto3

      • Methods inherited from class com.google.protobuf.AbstractMessage.Builder

        findInitializationErrors, getInitializationErrorString, internalMergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, newUninitializedMessageException, toString

      • Methods inherited from class com.google.protobuf.AbstractMessageLite.Builder

        addAll, addAll, mergeDelimitedFrom, mergeDelimitedFrom, mergeFrom, newUninitializedMessageException

      • Methods inherited from interface com.google.protobuf.Message.Builder

        mergeDelimitedFrom, mergeDelimitedFrom

      • Methods inherited from interface com.google.protobuf.MessageLite.Builder

        mergeFrom

      • Methods inherited from interface com.google.protobuf.MessageOrBuilder

        findInitializationErrors, getAllFields, getField, getInitializationErrorString, getOneofFieldDescriptor, getRepeatedField, getRepeatedFieldCount, getUnknownFields, hasField, hasOneof

    • Method Detail

      • getDescriptor

        public static final com.google.protobuf.Descriptors.Descriptor getDescriptor()

      • internalGetFieldAccessorTable

        protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable()
        Specified by:
        internalGetFieldAccessorTable in class com.google.protobuf.GeneratedMessageV3.Builder<PartialResultSet.Builder>

      • clear

        public PartialResultSet.Builder clear()
        Specified by:
        clear in interface com.google.protobuf.Message.Builder
        Specified by:
        clear in interface com.google.protobuf.MessageLite.Builder
        Overrides:
        clear in class com.google.protobuf.GeneratedMessageV3.Builder<PartialResultSet.Builder>

      • getDescriptorForType

        public com.google.protobuf.Descriptors.Descriptor getDescriptorForType()
        Specified by:
        getDescriptorForType in interface com.google.protobuf.Message.Builder
        Specified by:
        getDescriptorForType in interface com.google.protobuf.MessageOrBuilder
        Overrides:
        getDescriptorForType in class com.google.protobuf.GeneratedMessageV3.Builder<PartialResultSet.Builder>

      • getDefaultInstanceForType

        public PartialResultSet getDefaultInstanceForType()
        Specified by:
        getDefaultInstanceForType in interface com.google.protobuf.MessageLiteOrBuilder
        Specified by:
        getDefaultInstanceForType in interface com.google.protobuf.MessageOrBuilder

      • build

        public PartialResultSet build()
        Specified by:
        build in interface com.google.protobuf.Message.Builder
        Specified by:
        build in interface com.google.protobuf.MessageLite.Builder

      • buildPartial

        public PartialResultSet buildPartial()
        Specified by:
        buildPartial in interface com.google.protobuf.Message.Builder
        Specified by:
        buildPartial in interface com.google.protobuf.MessageLite.Builder

      • clone

        public PartialResultSet.Builder clone()
        Specified by:
        clone in interface com.google.protobuf.Message.Builder
        Specified by:
        clone in interface com.google.protobuf.MessageLite.Builder
        Overrides:
        clone in class com.google.protobuf.GeneratedMessageV3.Builder<PartialResultSet.Builder>

      • setField

        public PartialResultSet.Builder setField​(com.google.protobuf.Descriptors.FieldDescriptor field,
                                         Object value)
        Specified by:
        setField in interface com.google.protobuf.Message.Builder
        Overrides:
        setField in class com.google.protobuf.GeneratedMessageV3.Builder<PartialResultSet.Builder>

      • clearField

        public PartialResultSet.Builder clearField​(com.google.protobuf.Descriptors.FieldDescriptor field)
        Specified by:
        clearField in interface com.google.protobuf.Message.Builder
        Overrides:
        clearField in class com.google.protobuf.GeneratedMessageV3.Builder<PartialResultSet.Builder>

      • clearOneof

        public PartialResultSet.Builder clearOneof​(com.google.protobuf.Descriptors.OneofDescriptor oneof)
        Specified by:
        clearOneof in interface com.google.protobuf.Message.Builder
        Overrides:
        clearOneof in class com.google.protobuf.GeneratedMessageV3.Builder<PartialResultSet.Builder>

      • setRepeatedField

        public PartialResultSet.Builder setRepeatedField​(com.google.protobuf.Descriptors.FieldDescriptor field,
                                                 int index,
                                                 Object value)
        Specified by:
        setRepeatedField in interface com.google.protobuf.Message.Builder
        Overrides:
        setRepeatedField in class com.google.protobuf.GeneratedMessageV3.Builder<PartialResultSet.Builder>

      • addRepeatedField

        public PartialResultSet.Builder addRepeatedField​(com.google.protobuf.Descriptors.FieldDescriptor field,
                                                 Object value)
        Specified by:
        addRepeatedField in interface com.google.protobuf.Message.Builder
        Overrides:
        addRepeatedField in class com.google.protobuf.GeneratedMessageV3.Builder<PartialResultSet.Builder>

      • mergeFrom

        public PartialResultSet.Builder mergeFrom​(com.google.protobuf.Message other)
        Specified by:
        mergeFrom in interface com.google.protobuf.Message.Builder
        Overrides:
        mergeFrom in class com.google.protobuf.AbstractMessage.Builder<PartialResultSet.Builder>

      • isInitialized

        public final boolean isInitialized()
        Specified by:
        isInitialized in interface com.google.protobuf.MessageLiteOrBuilder
        Overrides:
        isInitialized in class com.google.protobuf.GeneratedMessageV3.Builder<PartialResultSet.Builder>

      • mergeFrom

        public PartialResultSet.Builder mergeFrom​(com.google.protobuf.CodedInputStream input,
                                          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                                   throws IOException
        Specified by:
        mergeFrom in interface com.google.protobuf.Message.Builder
        Specified by:
        mergeFrom in interface com.google.protobuf.MessageLite.Builder
        Overrides:
        mergeFrom in class com.google.protobuf.AbstractMessage.Builder<PartialResultSet.Builder>
        Throws:
        IOException

      • hasMetadata

        public boolean hasMetadata()
         Metadata about the result set, such as row type information.
 Only present in the first response.
        .google.spanner.v1.ResultSetMetadata metadata = 1;
        Specified by:
        hasMetadata in interface PartialResultSetOrBuilder
        Returns:
        Whether the metadata field is set.

      • getMetadata

        public ResultSetMetadata getMetadata()
         Metadata about the result set, such as row type information.
 Only present in the first response.
        .google.spanner.v1.ResultSetMetadata metadata = 1;
        Specified by:
        getMetadata in interface PartialResultSetOrBuilder
        Returns:
        The metadata.

      • setMetadata

        public 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;

      • setMetadata

        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;

      • mergeMetadata

        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;

      • clearMetadata

        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;

      • getMetadataBuilder

        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;

      • getValuesList

        public List<com.google.protobuf.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;
        Specified by:
        getValuesList in interface PartialResultSetOrBuilder

      • getValuesCount

        public 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;
        Specified by:
        getValuesCount in interface PartialResultSetOrBuilder

      • getValues

        public com.google.protobuf.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;
        Specified by:
        getValues in interface PartialResultSetOrBuilder

      • setValues

        public PartialResultSet.Builder setValues​(int index,
                                          com.google.protobuf.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;

      • setValues

        public PartialResultSet.Builder setValues​(int index,
                                          com.google.protobuf.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;

      • addValues

        public PartialResultSet.Builder addValues​(com.google.protobuf.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;

      • addValues

        public PartialResultSet.Builder addValues​(int index,
                                          com.google.protobuf.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;

      • addValues

        public PartialResultSet.Builder addValues​(com.google.protobuf.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;

      • addValues

        public PartialResultSet.Builder addValues​(int index,
                                          com.google.protobuf.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;

      • addAllValues

        public PartialResultSet.Builder addAllValues​(Iterable<? extends com.google.protobuf.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;

      • clearValues

        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;

      • removeValues

        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;

      • getValuesBuilder

        public com.google.protobuf.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;

      • getValuesOrBuilder

        public com.google.protobuf.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;
        Specified by:
        getValuesOrBuilder in interface PartialResultSetOrBuilder

      • getValuesOrBuilderList

        public List<? extends com.google.protobuf.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;
        Specified by:
        getValuesOrBuilderList in interface PartialResultSetOrBuilder

      • addValuesBuilder

        public com.google.protobuf.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;

      • addValuesBuilder

        public com.google.protobuf.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;

      • getValuesBuilderList

        public List<com.google.protobuf.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;

      • getChunkedValue

        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;
        Specified by:
        getChunkedValue in interface PartialResultSetOrBuilder
        Returns:
        The chunkedValue.

      • setChunkedValue

        public 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;
        Parameters:
        value - The chunkedValue to set.
        Returns:
        This builder for chaining.

      • clearChunkedValue

        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;
        Returns:
        This builder for chaining.

      • getResumeToken

        public com.google.protobuf.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;
        Specified by:
        getResumeToken in interface PartialResultSetOrBuilder
        Returns:
        The resumeToken.

      • setResumeToken

        public PartialResultSet.Builder setResumeToken​(com.google.protobuf.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;
        Parameters:
        value - The resumeToken to set.
        Returns:
        This builder for chaining.

      • clearResumeToken

        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;
        Returns:
        This builder for chaining.

      • hasStats

        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;
        Specified by:
        hasStats in interface PartialResultSetOrBuilder
        Returns:
        Whether the stats field is set.

      • getStats

        public 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;
        Specified by:
        getStats in interface PartialResultSetOrBuilder
        Returns:
        The stats.

      • setStats

        public 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;

      • setStats

        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;

      • mergeStats

        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;

      • clearStats

        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;

      • getStatsBuilder

        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;

      • getStatsOrBuilder

        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;
        Specified by:
        getStatsOrBuilder in interface PartialResultSetOrBuilder

      • setUnknownFields

        public final PartialResultSet.Builder setUnknownFields​(com.google.protobuf.UnknownFieldSet unknownFields)
        Specified by:
        setUnknownFields in interface com.google.protobuf.Message.Builder
        Overrides:
        setUnknownFields in class com.google.protobuf.GeneratedMessageV3.Builder<PartialResultSet.Builder>

      • mergeUnknownFields

        public final PartialResultSet.Builder mergeUnknownFields​(com.google.protobuf.UnknownFieldSet unknownFields)
        Specified by:
        mergeUnknownFields in interface com.google.protobuf.Message.Builder
        Overrides:
        mergeUnknownFields in class com.google.protobuf.GeneratedMessageV3.Builder<PartialResultSet.Builder>