vendor/google.golang.org/genproto/googleapis/spanner/v1/result_set.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: google/spanner/v1/result_set.proto
   3
   4 package spanner
   5
   6 import proto "github.com/golang/protobuf/proto"
   7 import fmt "fmt"
   8 import math "math"
   9 import _ "google.golang.org/genproto/googleapis/api/annotations"
  10 import google_protobuf1 "github.com/golang/protobuf/ptypes/struct"
  11
  12 // Reference imports to suppress errors if they are not otherwise used.
  13 var _ = proto.Marshal
  14 var _ = fmt.Errorf
  15 var _ = math.Inf
  16
  17 // Results from [Read][google.spanner.v1.Spanner.Read] or
  18 // [ExecuteSql][google.spanner.v1.Spanner.ExecuteSql].
  19 type ResultSet struct {
  20         // Metadata about the result set, such as row type information.
  21         Metadata *ResultSetMetadata `protobuf:"bytes,1,opt,name=metadata" json:"metadata,omitempty"`
  22         // Each element in `rows` is a row whose format is defined by
  23         // [metadata.row_type][google.spanner.v1.ResultSetMetadata.row_type]. The ith element
  24         // in each row matches the ith field in
  25         // [metadata.row_type][google.spanner.v1.ResultSetMetadata.row_type]. Elements are
  26         // encoded based on type as described
  27         // [here][google.spanner.v1.TypeCode].
  28         Rows []*google_protobuf1.ListValue `protobuf:"bytes,2,rep,name=rows" json:"rows,omitempty"`
  29         // Query plan and execution statistics for the query that produced this
  30         // result set. These can be requested by setting
  31         // [ExecuteSqlRequest.query_mode][google.spanner.v1.ExecuteSqlRequest.query_mode].
  32         Stats *ResultSetStats `protobuf:"bytes,3,opt,name=stats" json:"stats,omitempty"`
  33 }
  34
  35 func (m *ResultSet) Reset()                    { *m = ResultSet{} }
  36 func (m *ResultSet) String() string            { return proto.CompactTextString(m) }
  37 func (*ResultSet) ProtoMessage()               {}
  38 func (*ResultSet) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} }
  39
  40 func (m *ResultSet) GetMetadata() *ResultSetMetadata {
  41         if m != nil {
  42                 return m.Metadata
  43         }
  44         return nil
  45 }
  46
  47 func (m *ResultSet) GetRows() []*google_protobuf1.ListValue {
  48         if m != nil {
  49                 return m.Rows
  50         }
  51         return nil
  52 }
  53
  54 func (m *ResultSet) GetStats() *ResultSetStats {
  55         if m != nil {
  56                 return m.Stats
  57         }
  58         return nil
  59 }
  60
  61 // Partial results from a streaming read or SQL query. Streaming reads and
  62 // SQL queries better tolerate large result sets, large rows, and large
  63 // values, but are a little trickier to consume.
  64 type PartialResultSet struct {
  65         // Metadata about the result set, such as row type information.
  66         // Only present in the first response.
  67         Metadata *ResultSetMetadata `protobuf:"bytes,1,opt,name=metadata" json:"metadata,omitempty"`
  68         // A streamed result set consists of a stream of values, which might
  69         // be split into many `PartialResultSet` messages to accommodate
  70         // large rows and/or large values. Every N complete values defines a
  71         // row, where N is equal to the number of entries in
  72         // [metadata.row_type.fields][google.spanner.v1.StructType.fields].
  73         //
  74         // Most values are encoded based on type as described
  75         // [here][google.spanner.v1.TypeCode].
  76         //
  77         // It is possible that the last value in values is "chunked",
  78         // meaning that the rest of the value is sent in subsequent
  79         // `PartialResultSet`(s). This is denoted by the [chunked_value][google.spanner.v1.PartialResultSet.chunked_value]
  80         // field. Two or more chunked values can be merged to form a
  81         // complete value as follows:
  82         //
  83         //   * `bool/number/null`: cannot be chunked
  84         //   * `string`: concatenate the strings
  85         //   * `list`: concatenate the lists. If the last element in a list is a
  86         //     `string`, `list`, or `object`, merge it with the first element in
  87         //     the next list by applying these rules recursively.
  88         //   * `object`: concatenate the (field name, field value) pairs. If a
  89         //     field name is duplicated, then apply these rules recursively
  90         //     to merge the field values.
  91         //
  92         // Some examples of merging:
  93         //
  94         //     # Strings are concatenated.
  95         //     "foo", "bar" => "foobar"
  96         //
  97         //     # Lists of non-strings are concatenated.
  98         //     [2, 3], [4] => [2, 3, 4]
  99         //
 100         //     # Lists are concatenated, but the last and first elements are merged
 101         //     # because they are strings.
 102         //     ["a", "b"], ["c", "d"] => ["a", "bc", "d"]
 103         //
 104         //     # Lists are concatenated, but the last and first elements are merged
 105         //     # because they are lists. Recursively, the last and first elements
 106         //     # of the inner lists are merged because they are strings.
 107         //     ["a", ["b", "c"]], [["d"], "e"] => ["a", ["b", "cd"], "e"]
 108         //
 109         //     # Non-overlapping object fields are combined.
 110         //     {"a": "1"}, {"b": "2"} => {"a": "1", "b": 2"}
 111         //
 112         //     # Overlapping object fields are merged.
 113         //     {"a": "1"}, {"a": "2"} => {"a": "12"}
 114         //
 115         //     # Examples of merging objects containing lists of strings.
 116         //     {"a": ["1"]}, {"a": ["2"]} => {"a": ["12"]}
 117         //
 118         // For a more complete example, suppose a streaming SQL query is
 119         // yielding a result set whose rows contain a single string
 120         // field. The following `PartialResultSet`s might be yielded:
 121         //
 122         //     {
 123         //       "metadata": { ... }
 124         //       "values": ["Hello", "W"]
 125         //       "chunked_value": true
 126         //       "resume_token": "Af65..."
 127         //     }
 128         //     {
 129         //       "values": ["orl"]
 130         //       "chunked_value": true
 131         //       "resume_token": "Bqp2..."
 132         //     }
 133         //     {
 134         //       "values": ["d"]
 135         //       "resume_token": "Zx1B..."
 136         //     }
 137         //
 138         // This sequence of `PartialResultSet`s encodes two rows, one
 139         // containing the field value `"Hello"`, and a second containing the
 140         // field value `"World" = "W" + "orl" + "d"`.
 141         Values []*google_protobuf1.Value `protobuf:"bytes,2,rep,name=values" json:"values,omitempty"`
 142         // If true, then the final value in [values][google.spanner.v1.PartialResultSet.values] is chunked, and must
 143         // be combined with more values from subsequent `PartialResultSet`s
 144         // to obtain a complete field value.
 145         ChunkedValue bool `protobuf:"varint,3,opt,name=chunked_value,json=chunkedValue" json:"chunked_value,omitempty"`
 146         // Streaming calls might be interrupted for a variety of reasons, such
 147         // as TCP connection loss. If this occurs, the stream of results can
 148         // be resumed by re-sending the original request and including
 149         // `resume_token`. Note that executing any other transaction in the
 150         // same session invalidates the token.
 151         ResumeToken []byte `protobuf:"bytes,4,opt,name=resume_token,json=resumeToken,proto3" json:"resume_token,omitempty"`
 152         // Query plan and execution statistics for the query that produced this
 153         // streaming result set. These can be requested by setting
 154         // [ExecuteSqlRequest.query_mode][google.spanner.v1.ExecuteSqlRequest.query_mode] and are sent
 155         // only once with the last response in the stream.
 156         Stats *ResultSetStats `protobuf:"bytes,5,opt,name=stats" json:"stats,omitempty"`
 157 }
 158
 159 func (m *PartialResultSet) Reset()                    { *m = PartialResultSet{} }
 160 func (m *PartialResultSet) String() string            { return proto.CompactTextString(m) }
 161 func (*PartialResultSet) ProtoMessage()               {}
 162 func (*PartialResultSet) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{1} }
 163
 164 func (m *PartialResultSet) GetMetadata() *ResultSetMetadata {
 165         if m != nil {
 166                 return m.Metadata
 167         }
 168         return nil
 169 }
 170
 171 func (m *PartialResultSet) GetValues() []*google_protobuf1.Value {
 172         if m != nil {
 173                 return m.Values
 174         }
 175         return nil
 176 }
 177
 178 func (m *PartialResultSet) GetChunkedValue() bool {
 179         if m != nil {
 180                 return m.ChunkedValue
 181         }
 182         return false
 183 }
 184
 185 func (m *PartialResultSet) GetResumeToken() []byte {
 186         if m != nil {
 187                 return m.ResumeToken
 188         }
 189         return nil
 190 }
 191
 192 func (m *PartialResultSet) GetStats() *ResultSetStats {
 193         if m != nil {
 194                 return m.Stats
 195         }
 196         return nil
 197 }
 198
 199 // Metadata about a [ResultSet][google.spanner.v1.ResultSet] or [PartialResultSet][google.spanner.v1.PartialResultSet].
 200 type ResultSetMetadata struct {
 201         // Indicates the field names and types for the rows in the result
 202         // set.  For example, a SQL query like `"SELECT UserId, UserName FROM
 203         // Users"` could return a `row_type` value like:
 204         //
 205         //     "fields": [
 206         //       { "name": "UserId", "type": { "code": "INT64" } },
 207         //       { "name": "UserName", "type": { "code": "STRING" } },
 208         //     ]
 209         RowType *StructType `protobuf:"bytes,1,opt,name=row_type,json=rowType" json:"row_type,omitempty"`
 210         // If the read or SQL query began a transaction as a side-effect, the
 211         // information about the new transaction is yielded here.
 212         Transaction *Transaction `protobuf:"bytes,2,opt,name=transaction" json:"transaction,omitempty"`
 213 }
 214
 215 func (m *ResultSetMetadata) Reset()                    { *m = ResultSetMetadata{} }
 216 func (m *ResultSetMetadata) String() string            { return proto.CompactTextString(m) }
 217 func (*ResultSetMetadata) ProtoMessage()               {}
 218 func (*ResultSetMetadata) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{2} }
 219
 220 func (m *ResultSetMetadata) GetRowType() *StructType {
 221         if m != nil {
 222                 return m.RowType
 223         }
 224         return nil
 225 }
 226
 227 func (m *ResultSetMetadata) GetTransaction() *Transaction {
 228         if m != nil {
 229                 return m.Transaction
 230         }
 231         return nil
 232 }
 233
 234 // Additional statistics about a [ResultSet][google.spanner.v1.ResultSet] or [PartialResultSet][google.spanner.v1.PartialResultSet].
 235 type ResultSetStats struct {
 236         // [QueryPlan][google.spanner.v1.QueryPlan] for the query associated with this result.
 237         QueryPlan *QueryPlan `protobuf:"bytes,1,opt,name=query_plan,json=queryPlan" json:"query_plan,omitempty"`
 238         // Aggregated statistics from the execution of the query. Only present when
 239         // the query is profiled. For example, a query could return the statistics as
 240         // follows:
 241         //
 242         //     {
 243         //       "rows_returned": "3",
 244         //       "elapsed_time": "1.22 secs",
 245         //       "cpu_time": "1.19 secs"
 246         //     }
 247         QueryStats *google_protobuf1.Struct `protobuf:"bytes,2,opt,name=query_stats,json=queryStats" json:"query_stats,omitempty"`
 248 }
 249
 250 func (m *ResultSetStats) Reset()                    { *m = ResultSetStats{} }
 251 func (m *ResultSetStats) String() string            { return proto.CompactTextString(m) }
 252 func (*ResultSetStats) ProtoMessage()               {}
 253 func (*ResultSetStats) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{3} }
 254
 255 func (m *ResultSetStats) GetQueryPlan() *QueryPlan {
 256         if m != nil {
 257                 return m.QueryPlan
 258         }
 259         return nil
 260 }
 261
 262 func (m *ResultSetStats) GetQueryStats() *google_protobuf1.Struct {
 263         if m != nil {
 264                 return m.QueryStats
 265         }
 266         return nil
 267 }
 268
 269 func init() {
 270         proto.RegisterType((*ResultSet)(nil), "google.spanner.v1.ResultSet")
 271         proto.RegisterType((*PartialResultSet)(nil), "google.spanner.v1.PartialResultSet")
 272         proto.RegisterType((*ResultSetMetadata)(nil), "google.spanner.v1.ResultSetMetadata")
 273         proto.RegisterType((*ResultSetStats)(nil), "google.spanner.v1.ResultSetStats")
 274 }
 275
 276 func init() { proto.RegisterFile("google/spanner/v1/result_set.proto", fileDescriptor3) }
 277
 278 var fileDescriptor3 = []byte{
 279         // 482 bytes of a gzipped FileDescriptorProto
 280         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x93, 0xcb, 0x6e, 0x13, 0x31,
 281         0x14, 0x86, 0x35, 0xe9, 0x85, 0xd4, 0x13, 0x10, 0xb5, 0x04, 0x1d, 0x45, 0x05, 0xa5, 0x29, 0x8b,
 282         0xac, 0x3c, 0x4a, 0x59, 0x10, 0xa9, 0x9b, 0xaa, 0x2c, 0xd8, 0x80, 0x14, 0x9c, 0xa8, 0x0b, 0x36,
 283         0xa3, 0xd3, 0xc4, 0x0c, 0xa3, 0x3a, 0xf6, 0xd4, 0xf6, 0x24, 0xca, 0x82, 0x25, 0x62, 0xc9, 0x7b,
 284         0xf0, 0x00, 0x3c, 0x1f, 0xf2, 0x25, 0x17, 0x98, 0x08, 0x09, 0xa9, 0x3b, 0xc7, 0xfe, 0xfe, 0xf3,
 285         0x9f, 0xff, 0xcc, 0x09, 0xea, 0xe6, 0x52, 0xe6, 0x9c, 0xa5, 0xba, 0x04, 0x21, 0x98, 0x4a, 0xe7,
 286         0xfd, 0x54, 0x31, 0x5d, 0x71, 0x93, 0x69, 0x66, 0x48, 0xa9, 0xa4, 0x91, 0xf8, 0xd8, 0x33, 0x24,
 287         0x30, 0x64, 0xde, 0x6f, 0x9f, 0x06, 0x19, 0x94, 0x45, 0x0a, 0x42, 0x48, 0x03, 0xa6, 0x90, 0x42,
 288         0x7b, 0xc1, 0xfa, 0xd5, 0xfd, 0xba, 0xad, 0x3e, 0xa7, 0xda, 0xa8, 0x6a, 0x12, 0xca, 0xb5, 0x77,
 289         0x58, 0xde, 0x57, 0x4c, 0x2d, 0xb3, 0x92, 0x83, 0x08, 0xcc, 0x79, 0x9d, 0x31, 0x0a, 0x84, 0x86,
 290         0x89, 0xf5, 0xf9, 0xcb, 0x66, 0x1b, 0x5a, 0x96, 0xcc, 0xbf, 0x76, 0x7f, 0x45, 0xe8, 0x88, 0xba,
 291         0x28, 0x23, 0x66, 0xf0, 0x15, 0x6a, 0xce, 0x98, 0x81, 0x29, 0x18, 0x48, 0xa2, 0x4e, 0xd4, 0x8b,
 292         0x2f, 0x5e, 0x91, 0x5a, 0x2c, 0xb2, 0xe6, 0x3f, 0x04, 0x96, 0xae, 0x55, 0x98, 0xa0, 0x7d, 0x25,
 293         0x17, 0x3a, 0x69, 0x74, 0xf6, 0x7a, 0xf1, 0x45, 0x7b, 0xa5, 0x5e, 0x65, 0x24, 0xef, 0x0b, 0x6d,
 294         0x6e, 0x80, 0x57, 0x8c, 0x3a, 0x0e, 0xbf, 0x41, 0x07, 0xda, 0x80, 0xd1, 0xc9, 0x9e, 0xb3, 0x3b,
 295         0xfb, 0x97, 0xdd, 0xc8, 0x82, 0xd4, 0xf3, 0xdd, 0x6f, 0x0d, 0xf4, 0x74, 0x08, 0xca, 0x14, 0xc0,
 296         0x1f, 0xb6, 0xff, 0xc3, 0xb9, 0x6d, 0x6f, 0x95, 0xe0, 0x79, 0x2d, 0x81, 0xef, 0x3e, 0x50, 0xf8,
 297         0x1c, 0x3d, 0x9e, 0x7c, 0xa9, 0xc4, 0x1d, 0x9b, 0x66, 0xee, 0xc6, 0xe5, 0x68, 0xd2, 0x56, 0xb8,
 298         0x74, 0x30, 0x3e, 0x43, 0x2d, 0xbb, 0x2e, 0x33, 0x96, 0x19, 0x79, 0xc7, 0x44, 0xb2, 0xdf, 0x89,
 299         0x7a, 0x2d, 0x1a, 0xfb, 0xbb, 0xb1, 0xbd, 0xda, 0xcc, 0xe1, 0xe0, 0x3f, 0xe7, 0xf0, 0x23, 0x42,
 300         0xc7, 0xb5, 0x40, 0x78, 0x80, 0x9a, 0x4a, 0x2e, 0x32, 0xfb, 0xa1, 0xc3, 0x20, 0x5e, 0xec, 0xa8,
 301         0x38, 0x72, 0x0b, 0x37, 0x5e, 0x96, 0x8c, 0x3e, 0x52, 0x72, 0x61, 0x0f, 0xf8, 0x0a, 0xc5, 0x5b,
 302         0x3b, 0x94, 0x34, 0x9c, 0xf8, 0xe5, 0x0e, 0xf1, 0x78, 0x43, 0xd1, 0x6d, 0x49, 0xf7, 0x7b, 0x84,
 303         0x9e, 0xfc, 0xd9, 0x2b, 0xbe, 0x44, 0x68, 0xb3, 0xbc, 0xa1, 0xa1, 0xd3, 0x1d, 0x35, 0x3f, 0x5a,
 304         0x68, 0xc8, 0x41, 0xd0, 0xa3, 0xfb, 0xd5, 0x11, 0x0f, 0x50, 0xec, 0xc5, 0x7e, 0x40, 0xbe, 0xa3,
 305         0x93, 0xda, 0x77, 0xf1, 0x61, 0xa8, 0x37, 0x72, 0xb6, 0xd7, 0x5f, 0xd1, 0xb3, 0x89, 0x9c, 0xd5,
 306         0x7d, 0xae, 0x37, 0xfd, 0x0d, 0xad, 0x7c, 0x18, 0x7d, 0x1a, 0x04, 0x28, 0x97, 0x1c, 0x44, 0x4e,
 307         0xa4, 0xca, 0xd3, 0x9c, 0x09, 0x57, 0x3c, 0xf5, 0x4f, 0x50, 0x16, 0x7a, 0xeb, 0x4f, 0x74, 0x19,
 308         0x8e, 0x3f, 0x1b, 0x27, 0xef, 0xbc, 0xf4, 0x2d, 0x97, 0xd5, 0x94, 0x8c, 0x82, 0xcb, 0x4d, 0xff,
 309         0xf6, 0xd0, 0xc9, 0x5f, 0xff, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xe1, 0x15, 0x1f, 0xa6, 0x3e, 0x04,
 310         0x00, 0x00,
 311 }