Debian Codegraph @

bigtable/apiv2/bigtablepb/data.pb.go

raw
1 // Copyright 2025 Google LLC
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 // Code generated by protoc-gen-go. DO NOT EDIT.
16 // versions:
17 // protoc-gen-go v1.35.2
18 // protoc v4.25.7
19 // source: google/bigtable/v2/data.proto
20
21 package bigtablepb
22
23 import (
24 _ "google.golang.org/genproto/googleapis/api/annotations"
25 date "google.golang.org/genproto/googleapis/type/date"
26 protoreflect "google.golang.org/protobuf/reflect/protoreflect"
27 protoimpl "google.golang.org/protobuf/runtime/protoimpl"
28 timestamppb "google.golang.org/protobuf/types/known/timestamppb"
29 reflect "reflect"
30 sync "sync"
31 )
32
33 const (
34 // Verify that this generated code is sufficiently up-to-date.
35 _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
36 // Verify that runtime/protoimpl is sufficiently up-to-date.
37 _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
38 )
39
40 // Specifies the complete (requested) contents of a single row of a table.
41 // Rows which exceed 256MiB in size cannot be read in full.
42 type Row struct {
43 state protoimpl.MessageState
44 sizeCache protoimpl.SizeCache
45 unknownFields protoimpl.UnknownFields
46
47 // The unique key which identifies this row within its table. This is the same
48 // key that's used to identify the row in, for example, a MutateRowRequest.
49 // May contain any non-empty byte string up to 4KiB in length.
50 Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
51 // May be empty, but only if the entire row is empty.
52 // The mutual ordering of column families is not specified.
53 Families []*Family `protobuf:"bytes,2,rep,name=families,proto3" json:"families,omitempty"`
54 }
55
56 func (x *Row) Reset() {
57 *x = Row{}
58 mi := &file_google_bigtable_v2_data_proto_msgTypes[0]
59 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
60 ms.StoreMessageInfo(mi)
61 }
62
63 func (x *Row) String() string {
64 return protoimpl.X.MessageStringOf(x)
65 }
66
67 func (*Row) ProtoMessage() {}
68
69 func (x *Row) ProtoReflect() protoreflect.Message {
70 mi := &file_google_bigtable_v2_data_proto_msgTypes[0]
71 if x != nil {
72 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
73 if ms.LoadMessageInfo() == nil {
74 ms.StoreMessageInfo(mi)
75 }
76 return ms
77 }
78 return mi.MessageOf(x)
79 }
80
81 // Deprecated: Use Row.ProtoReflect.Descriptor instead.
82 func (*Row) Descriptor() ([]byte, []int) {
83 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{0}
84 }
85
86 func (x *Row) GetKey() []byte {
87 if x != nil {
88 return x.Key
89 }
90 return nil
91 }
92
93 func (x *Row) GetFamilies() []*Family {
94 if x != nil {
95 return x.Families
96 }
97 return nil
98 }
99
100 // Specifies (some of) the contents of a single row/column family intersection
101 // of a table.
102 type Family struct {
103 state protoimpl.MessageState
104 sizeCache protoimpl.SizeCache
105 unknownFields protoimpl.UnknownFields
106
107 // The unique key which identifies this family within its row. This is the
108 // same key that's used to identify the family in, for example, a RowFilter
109 // which sets its "family_name_regex_filter" field.
110 // Must match `[-_.a-zA-Z0-9]+`, except that AggregatingRowProcessors may
111 // produce cells in a sentinel family with an empty name.
112 // Must be no greater than 64 characters in length.
113 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
114 // Must not be empty. Sorted in order of increasing "qualifier".
115 Columns []*Column `protobuf:"bytes,2,rep,name=columns,proto3" json:"columns,omitempty"`
116 }
117
118 func (x *Family) Reset() {
119 *x = Family{}
120 mi := &file_google_bigtable_v2_data_proto_msgTypes[1]
121 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
122 ms.StoreMessageInfo(mi)
123 }
124
125 func (x *Family) String() string {
126 return protoimpl.X.MessageStringOf(x)
127 }
128
129 func (*Family) ProtoMessage() {}
130
131 func (x *Family) ProtoReflect() protoreflect.Message {
132 mi := &file_google_bigtable_v2_data_proto_msgTypes[1]
133 if x != nil {
134 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
135 if ms.LoadMessageInfo() == nil {
136 ms.StoreMessageInfo(mi)
137 }
138 return ms
139 }
140 return mi.MessageOf(x)
141 }
142
143 // Deprecated: Use Family.ProtoReflect.Descriptor instead.
144 func (*Family) Descriptor() ([]byte, []int) {
145 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{1}
146 }
147
148 func (x *Family) GetName() string {
149 if x != nil {
150 return x.Name
151 }
152 return ""
153 }
154
155 func (x *Family) GetColumns() []*Column {
156 if x != nil {
157 return x.Columns
158 }
159 return nil
160 }
161
162 // Specifies (some of) the contents of a single row/column intersection of a
163 // table.
164 type Column struct {
165 state protoimpl.MessageState
166 sizeCache protoimpl.SizeCache
167 unknownFields protoimpl.UnknownFields
168
169 // The unique key which identifies this column within its family. This is the
170 // same key that's used to identify the column in, for example, a RowFilter
171 // which sets its `column_qualifier_regex_filter` field.
172 // May contain any byte string, including the empty string, up to 16kiB in
173 // length.
174 Qualifier []byte `protobuf:"bytes,1,opt,name=qualifier,proto3" json:"qualifier,omitempty"`
175 // Must not be empty. Sorted in order of decreasing "timestamp_micros".
176 Cells []*Cell `protobuf:"bytes,2,rep,name=cells,proto3" json:"cells,omitempty"`
177 }
178
179 func (x *Column) Reset() {
180 *x = Column{}
181 mi := &file_google_bigtable_v2_data_proto_msgTypes[2]
182 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
183 ms.StoreMessageInfo(mi)
184 }
185
186 func (x *Column) String() string {
187 return protoimpl.X.MessageStringOf(x)
188 }
189
190 func (*Column) ProtoMessage() {}
191
192 func (x *Column) ProtoReflect() protoreflect.Message {
193 mi := &file_google_bigtable_v2_data_proto_msgTypes[2]
194 if x != nil {
195 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
196 if ms.LoadMessageInfo() == nil {
197 ms.StoreMessageInfo(mi)
198 }
199 return ms
200 }
201 return mi.MessageOf(x)
202 }
203
204 // Deprecated: Use Column.ProtoReflect.Descriptor instead.
205 func (*Column) Descriptor() ([]byte, []int) {
206 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{2}
207 }
208
209 func (x *Column) GetQualifier() []byte {
210 if x != nil {
211 return x.Qualifier
212 }
213 return nil
214 }
215
216 func (x *Column) GetCells() []*Cell {
217 if x != nil {
218 return x.Cells
219 }
220 return nil
221 }
222
223 // Specifies (some of) the contents of a single row/column/timestamp of a table.
224 type Cell struct {
225 state protoimpl.MessageState
226 sizeCache protoimpl.SizeCache
227 unknownFields protoimpl.UnknownFields
228
229 // The cell's stored timestamp, which also uniquely identifies it within
230 // its column.
231 // Values are always expressed in microseconds, but individual tables may set
232 // a coarser granularity to further restrict the allowed values. For
233 // example, a table which specifies millisecond granularity will only allow
234 // values of `timestamp_micros` which are multiples of 1000.
235 TimestampMicros int64 `protobuf:"varint,1,opt,name=timestamp_micros,json=timestampMicros,proto3" json:"timestamp_micros,omitempty"`
236 // The value stored in the cell.
237 // May contain any byte string, including the empty string, up to 100MiB in
238 // length.
239 Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
240 // Labels applied to the cell by a [RowFilter][google.bigtable.v2.RowFilter].
241 Labels []string `protobuf:"bytes,3,rep,name=labels,proto3" json:"labels,omitempty"`
242 }
243
244 func (x *Cell) Reset() {
245 *x = Cell{}
246 mi := &file_google_bigtable_v2_data_proto_msgTypes[3]
247 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
248 ms.StoreMessageInfo(mi)
249 }
250
251 func (x *Cell) String() string {
252 return protoimpl.X.MessageStringOf(x)
253 }
254
255 func (*Cell) ProtoMessage() {}
256
257 func (x *Cell) ProtoReflect() protoreflect.Message {
258 mi := &file_google_bigtable_v2_data_proto_msgTypes[3]
259 if x != nil {
260 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
261 if ms.LoadMessageInfo() == nil {
262 ms.StoreMessageInfo(mi)
263 }
264 return ms
265 }
266 return mi.MessageOf(x)
267 }
268
269 // Deprecated: Use Cell.ProtoReflect.Descriptor instead.
270 func (*Cell) Descriptor() ([]byte, []int) {
271 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{3}
272 }
273
274 func (x *Cell) GetTimestampMicros() int64 {
275 if x != nil {
276 return x.TimestampMicros
277 }
278 return 0
279 }
280
281 func (x *Cell) GetValue() []byte {
282 if x != nil {
283 return x.Value
284 }
285 return nil
286 }
287
288 func (x *Cell) GetLabels() []string {
289 if x != nil {
290 return x.Labels
291 }
292 return nil
293 }
294
295 // `Value` represents a dynamically typed value.
296 // The typed fields in `Value` are used as a transport encoding for the actual
297 // value (which may be of a more complex type). See the documentation of the
298 // `Type` message for more details.
299 type Value struct {
300 state protoimpl.MessageState
301 sizeCache protoimpl.SizeCache
302 unknownFields protoimpl.UnknownFields
303
304 // The verified `Type` of this `Value`, if it cannot be inferred.
305 //
306 // Read results will never specify the encoding for `type` since the value
307 // will already have been decoded by the server. Furthermore, the `type` will
308 // be omitted entirely if it can be inferred from a previous response. The
309 // exact semantics for inferring `type` will vary, and are therefore
310 // documented separately for each read method.
311 //
312 // When using composite types (Struct, Array, Map) only the outermost `Value`
313 // will specify the `type`. This top-level `type` will define the types for
314 // any nested `Struct' fields, `Array` elements, or `Map` key/value pairs.
315 // If a nested `Value` provides a `type` on write, the request will be
316 // rejected with INVALID_ARGUMENT.
317 Type *Type `protobuf:"bytes,7,opt,name=type,proto3" json:"type,omitempty"`
318 // Options for transporting values within the protobuf type system. A given
319 // `kind` may support more than one `type` and vice versa. On write, this is
320 // roughly analogous to a GoogleSQL literal.
321 //
322 // The value is `NULL` if none of the fields in `kind` is set. If `type` is
323 // also omitted on write, we will infer it based on the schema.
324 //
325 // Types that are assignable to Kind:
326 //
327 // *Value_RawValue
328 // *Value_RawTimestampMicros
329 // *Value_BytesValue
330 // *Value_StringValue
331 // *Value_IntValue
332 // *Value_BoolValue
333 // *Value_FloatValue
334 // *Value_TimestampValue
335 // *Value_DateValue
336 // *Value_ArrayValue
337 Kind isValue_Kind `protobuf_oneof:"kind"`
338 }
339
340 func (x *Value) Reset() {
341 *x = Value{}
342 mi := &file_google_bigtable_v2_data_proto_msgTypes[4]
343 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
344 ms.StoreMessageInfo(mi)
345 }
346
347 func (x *Value) String() string {
348 return protoimpl.X.MessageStringOf(x)
349 }
350
351 func (*Value) ProtoMessage() {}
352
353 func (x *Value) ProtoReflect() protoreflect.Message {
354 mi := &file_google_bigtable_v2_data_proto_msgTypes[4]
355 if x != nil {
356 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
357 if ms.LoadMessageInfo() == nil {
358 ms.StoreMessageInfo(mi)
359 }
360 return ms
361 }
362 return mi.MessageOf(x)
363 }
364
365 // Deprecated: Use Value.ProtoReflect.Descriptor instead.
366 func (*Value) Descriptor() ([]byte, []int) {
367 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{4}
368 }
369
370 func (x *Value) GetType() *Type {
371 if x != nil {
372 return x.Type
373 }
374 return nil
375 }
376
377 func (m *Value) GetKind() isValue_Kind {
378 if m != nil {
379 return m.Kind
380 }
381 return nil
382 }
383
384 func (x *Value) GetRawValue() []byte {
385 if x, ok := x.GetKind().(*Value_RawValue); ok {
386 return x.RawValue
387 }
388 return nil
389 }
390
391 func (x *Value) GetRawTimestampMicros() int64 {
392 if x, ok := x.GetKind().(*Value_RawTimestampMicros); ok {
393 return x.RawTimestampMicros
394 }
395 return 0
396 }
397
398 func (x *Value) GetBytesValue() []byte {
399 if x, ok := x.GetKind().(*Value_BytesValue); ok {
400 return x.BytesValue
401 }
402 return nil
403 }
404
405 func (x *Value) GetStringValue() string {
406 if x, ok := x.GetKind().(*Value_StringValue); ok {
407 return x.StringValue
408 }
409 return ""
410 }
411
412 func (x *Value) GetIntValue() int64 {
413 if x, ok := x.GetKind().(*Value_IntValue); ok {
414 return x.IntValue
415 }
416 return 0
417 }
418
419 func (x *Value) GetBoolValue() bool {
420 if x, ok := x.GetKind().(*Value_BoolValue); ok {
421 return x.BoolValue
422 }
423 return false
424 }
425
426 func (x *Value) GetFloatValue() float64 {
427 if x, ok := x.GetKind().(*Value_FloatValue); ok {
428 return x.FloatValue
429 }
430 return 0
431 }
432
433 func (x *Value) GetTimestampValue() *timestamppb.Timestamp {
434 if x, ok := x.GetKind().(*Value_TimestampValue); ok {
435 return x.TimestampValue
436 }
437 return nil
438 }
439
440 func (x *Value) GetDateValue() *date.Date {
441 if x, ok := x.GetKind().(*Value_DateValue); ok {
442 return x.DateValue
443 }
444 return nil
445 }
446
447 func (x *Value) GetArrayValue() *ArrayValue {
448 if x, ok := x.GetKind().(*Value_ArrayValue); ok {
449 return x.ArrayValue
450 }
451 return nil
452 }
453
454 type isValue_Kind interface {
455 isValue_Kind()
456 }
457
458 type Value_RawValue struct {
459 // Represents a raw byte sequence with no type information.
460 // The `type` field must be omitted.
461 RawValue []byte `protobuf:"bytes,8,opt,name=raw_value,json=rawValue,proto3,oneof"`
462 }
463
464 type Value_RawTimestampMicros struct {
465 // Represents a raw cell timestamp with no type information.
466 // The `type` field must be omitted.
467 RawTimestampMicros int64 `protobuf:"varint,9,opt,name=raw_timestamp_micros,json=rawTimestampMicros,proto3,oneof"`
468 }
469
470 type Value_BytesValue struct {
471 // Represents a typed value transported as a byte sequence.
472 BytesValue []byte `protobuf:"bytes,2,opt,name=bytes_value,json=bytesValue,proto3,oneof"`
473 }
474
475 type Value_StringValue struct {
476 // Represents a typed value transported as a string.
477 StringValue string `protobuf:"bytes,3,opt,name=string_value,json=stringValue,proto3,oneof"`
478 }
479
480 type Value_IntValue struct {
481 // Represents a typed value transported as an integer.
482 IntValue int64 `protobuf:"varint,6,opt,name=int_value,json=intValue,proto3,oneof"`
483 }
484
485 type Value_BoolValue struct {
486 // Represents a typed value transported as a boolean.
487 BoolValue bool `protobuf:"varint,10,opt,name=bool_value,json=boolValue,proto3,oneof"`
488 }
489
490 type Value_FloatValue struct {
491 // Represents a typed value transported as a floating point number.
492 // Does not support NaN or infinities.
493 FloatValue float64 `protobuf:"fixed64,11,opt,name=float_value,json=floatValue,proto3,oneof"`
494 }
495
496 type Value_TimestampValue struct {
497 // Represents a typed value transported as a timestamp.
498 TimestampValue *timestamppb.Timestamp `protobuf:"bytes,12,opt,name=timestamp_value,json=timestampValue,proto3,oneof"`
499 }
500
501 type Value_DateValue struct {
502 // Represents a typed value transported as a date.
503 DateValue *date.Date `protobuf:"bytes,13,opt,name=date_value,json=dateValue,proto3,oneof"`
504 }
505
506 type Value_ArrayValue struct {
507 // Represents a typed value transported as a sequence of values.
508 // To differentiate between `Struct`, `Array`, and `Map`, the outermost
509 // `Value` must provide an explicit `type` on write. This `type` will
510 // apply recursively to the nested `Struct` fields, `Array` elements,
511 // or `Map` key/value pairs, which *must not* supply their own `type`.
512 ArrayValue *ArrayValue `protobuf:"bytes,4,opt,name=array_value,json=arrayValue,proto3,oneof"`
513 }
514
515 func (*Value_RawValue) isValue_Kind() {}
516
517 func (*Value_RawTimestampMicros) isValue_Kind() {}
518
519 func (*Value_BytesValue) isValue_Kind() {}
520
521 func (*Value_StringValue) isValue_Kind() {}
522
523 func (*Value_IntValue) isValue_Kind() {}
524
525 func (*Value_BoolValue) isValue_Kind() {}
526
527 func (*Value_FloatValue) isValue_Kind() {}
528
529 func (*Value_TimestampValue) isValue_Kind() {}
530
531 func (*Value_DateValue) isValue_Kind() {}
532
533 func (*Value_ArrayValue) isValue_Kind() {}
534
535 // `ArrayValue` is an ordered list of `Value`.
536 type ArrayValue struct {
537 state protoimpl.MessageState
538 sizeCache protoimpl.SizeCache
539 unknownFields protoimpl.UnknownFields
540
541 // The ordered elements in the array.
542 Values []*Value `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
543 }
544
545 func (x *ArrayValue) Reset() {
546 *x = ArrayValue{}
547 mi := &file_google_bigtable_v2_data_proto_msgTypes[5]
548 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
549 ms.StoreMessageInfo(mi)
550 }
551
552 func (x *ArrayValue) String() string {
553 return protoimpl.X.MessageStringOf(x)
554 }
555
556 func (*ArrayValue) ProtoMessage() {}
557
558 func (x *ArrayValue) ProtoReflect() protoreflect.Message {
559 mi := &file_google_bigtable_v2_data_proto_msgTypes[5]
560 if x != nil {
561 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
562 if ms.LoadMessageInfo() == nil {
563 ms.StoreMessageInfo(mi)
564 }
565 return ms
566 }
567 return mi.MessageOf(x)
568 }
569
570 // Deprecated: Use ArrayValue.ProtoReflect.Descriptor instead.
571 func (*ArrayValue) Descriptor() ([]byte, []int) {
572 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{5}
573 }
574
575 func (x *ArrayValue) GetValues() []*Value {
576 if x != nil {
577 return x.Values
578 }
579 return nil
580 }
581
582 // Specifies a contiguous range of rows.
583 type RowRange struct {
584 state protoimpl.MessageState
585 sizeCache protoimpl.SizeCache
586 unknownFields protoimpl.UnknownFields
587
588 // The row key at which to start the range.
589 // If neither field is set, interpreted as the empty string, inclusive.
590 //
591 // Types that are assignable to StartKey:
592 //
593 // *RowRange_StartKeyClosed
594 // *RowRange_StartKeyOpen
595 StartKey isRowRange_StartKey `protobuf_oneof:"start_key"`
596 // The row key at which to end the range.
597 // If neither field is set, interpreted as the infinite row key, exclusive.
598 //
599 // Types that are assignable to EndKey:
600 //
601 // *RowRange_EndKeyOpen
602 // *RowRange_EndKeyClosed
603 EndKey isRowRange_EndKey `protobuf_oneof:"end_key"`
604 }
605
606 func (x *RowRange) Reset() {
607 *x = RowRange{}
608 mi := &file_google_bigtable_v2_data_proto_msgTypes[6]
609 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
610 ms.StoreMessageInfo(mi)
611 }
612
613 func (x *RowRange) String() string {
614 return protoimpl.X.MessageStringOf(x)
615 }
616
617 func (*RowRange) ProtoMessage() {}
618
619 func (x *RowRange) ProtoReflect() protoreflect.Message {
620 mi := &file_google_bigtable_v2_data_proto_msgTypes[6]
621 if x != nil {
622 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
623 if ms.LoadMessageInfo() == nil {
624 ms.StoreMessageInfo(mi)
625 }
626 return ms
627 }
628 return mi.MessageOf(x)
629 }
630
631 // Deprecated: Use RowRange.ProtoReflect.Descriptor instead.
632 func (*RowRange) Descriptor() ([]byte, []int) {
633 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{6}
634 }
635
636 func (m *RowRange) GetStartKey() isRowRange_StartKey {
637 if m != nil {
638 return m.StartKey
639 }
640 return nil
641 }
642
643 func (x *RowRange) GetStartKeyClosed() []byte {
644 if x, ok := x.GetStartKey().(*RowRange_StartKeyClosed); ok {
645 return x.StartKeyClosed
646 }
647 return nil
648 }
649
650 func (x *RowRange) GetStartKeyOpen() []byte {
651 if x, ok := x.GetStartKey().(*RowRange_StartKeyOpen); ok {
652 return x.StartKeyOpen
653 }
654 return nil
655 }
656
657 func (m *RowRange) GetEndKey() isRowRange_EndKey {
658 if m != nil {
659 return m.EndKey
660 }
661 return nil
662 }
663
664 func (x *RowRange) GetEndKeyOpen() []byte {
665 if x, ok := x.GetEndKey().(*RowRange_EndKeyOpen); ok {
666 return x.EndKeyOpen
667 }
668 return nil
669 }
670
671 func (x *RowRange) GetEndKeyClosed() []byte {
672 if x, ok := x.GetEndKey().(*RowRange_EndKeyClosed); ok {
673 return x.EndKeyClosed
674 }
675 return nil
676 }
677
678 type isRowRange_StartKey interface {
679 isRowRange_StartKey()
680 }
681
682 type RowRange_StartKeyClosed struct {
683 // Used when giving an inclusive lower bound for the range.
684 StartKeyClosed []byte `protobuf:"bytes,1,opt,name=start_key_closed,json=startKeyClosed,proto3,oneof"`
685 }
686
687 type RowRange_StartKeyOpen struct {
688 // Used when giving an exclusive lower bound for the range.
689 StartKeyOpen []byte `protobuf:"bytes,2,opt,name=start_key_open,json=startKeyOpen,proto3,oneof"`
690 }
691
692 func (*RowRange_StartKeyClosed) isRowRange_StartKey() {}
693
694 func (*RowRange_StartKeyOpen) isRowRange_StartKey() {}
695
696 type isRowRange_EndKey interface {
697 isRowRange_EndKey()
698 }
699
700 type RowRange_EndKeyOpen struct {
701 // Used when giving an exclusive upper bound for the range.
702 EndKeyOpen []byte `protobuf:"bytes,3,opt,name=end_key_open,json=endKeyOpen,proto3,oneof"`
703 }
704
705 type RowRange_EndKeyClosed struct {
706 // Used when giving an inclusive upper bound for the range.
707 EndKeyClosed []byte `protobuf:"bytes,4,opt,name=end_key_closed,json=endKeyClosed,proto3,oneof"`
708 }
709
710 func (*RowRange_EndKeyOpen) isRowRange_EndKey() {}
711
712 func (*RowRange_EndKeyClosed) isRowRange_EndKey() {}
713
714 // Specifies a non-contiguous set of rows.
715 type RowSet struct {
716 state protoimpl.MessageState
717 sizeCache protoimpl.SizeCache
718 unknownFields protoimpl.UnknownFields
719
720 // Single rows included in the set.
721 RowKeys [][]byte `protobuf:"bytes,1,rep,name=row_keys,json=rowKeys,proto3" json:"row_keys,omitempty"`
722 // Contiguous row ranges included in the set.
723 RowRanges []*RowRange `protobuf:"bytes,2,rep,name=row_ranges,json=rowRanges,proto3" json:"row_ranges,omitempty"`
724 }
725
726 func (x *RowSet) Reset() {
727 *x = RowSet{}
728 mi := &file_google_bigtable_v2_data_proto_msgTypes[7]
729 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
730 ms.StoreMessageInfo(mi)
731 }
732
733 func (x *RowSet) String() string {
734 return protoimpl.X.MessageStringOf(x)
735 }
736
737 func (*RowSet) ProtoMessage() {}
738
739 func (x *RowSet) ProtoReflect() protoreflect.Message {
740 mi := &file_google_bigtable_v2_data_proto_msgTypes[7]
741 if x != nil {
742 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
743 if ms.LoadMessageInfo() == nil {
744 ms.StoreMessageInfo(mi)
745 }
746 return ms
747 }
748 return mi.MessageOf(x)
749 }
750
751 // Deprecated: Use RowSet.ProtoReflect.Descriptor instead.
752 func (*RowSet) Descriptor() ([]byte, []int) {
753 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{7}
754 }
755
756 func (x *RowSet) GetRowKeys() [][]byte {
757 if x != nil {
758 return x.RowKeys
759 }
760 return nil
761 }
762
763 func (x *RowSet) GetRowRanges() []*RowRange {
764 if x != nil {
765 return x.RowRanges
766 }
767 return nil
768 }
769
770 // Specifies a contiguous range of columns within a single column family.
771 // The range spans from <column_family>:<start_qualifier> to
772 // <column_family>:<end_qualifier>, where both bounds can be either
773 // inclusive or exclusive.
774 type ColumnRange struct {
775 state protoimpl.MessageState
776 sizeCache protoimpl.SizeCache
777 unknownFields protoimpl.UnknownFields
778
779 // The name of the column family within which this range falls.
780 FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
781 // The column qualifier at which to start the range (within `column_family`).
782 // If neither field is set, interpreted as the empty string, inclusive.
783 //
784 // Types that are assignable to StartQualifier:
785 //
786 // *ColumnRange_StartQualifierClosed
787 // *ColumnRange_StartQualifierOpen
788 StartQualifier isColumnRange_StartQualifier `protobuf_oneof:"start_qualifier"`
789 // The column qualifier at which to end the range (within `column_family`).
790 // If neither field is set, interpreted as the infinite string, exclusive.
791 //
792 // Types that are assignable to EndQualifier:
793 //
794 // *ColumnRange_EndQualifierClosed
795 // *ColumnRange_EndQualifierOpen
796 EndQualifier isColumnRange_EndQualifier `protobuf_oneof:"end_qualifier"`
797 }
798
799 func (x *ColumnRange) Reset() {
800 *x = ColumnRange{}
801 mi := &file_google_bigtable_v2_data_proto_msgTypes[8]
802 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
803 ms.StoreMessageInfo(mi)
804 }
805
806 func (x *ColumnRange) String() string {
807 return protoimpl.X.MessageStringOf(x)
808 }
809
810 func (*ColumnRange) ProtoMessage() {}
811
812 func (x *ColumnRange) ProtoReflect() protoreflect.Message {
813 mi := &file_google_bigtable_v2_data_proto_msgTypes[8]
814 if x != nil {
815 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
816 if ms.LoadMessageInfo() == nil {
817 ms.StoreMessageInfo(mi)
818 }
819 return ms
820 }
821 return mi.MessageOf(x)
822 }
823
824 // Deprecated: Use ColumnRange.ProtoReflect.Descriptor instead.
825 func (*ColumnRange) Descriptor() ([]byte, []int) {
826 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{8}
827 }
828
829 func (x *ColumnRange) GetFamilyName() string {
830 if x != nil {
831 return x.FamilyName
832 }
833 return ""
834 }
835
836 func (m *ColumnRange) GetStartQualifier() isColumnRange_StartQualifier {
837 if m != nil {
838 return m.StartQualifier
839 }
840 return nil
841 }
842
843 func (x *ColumnRange) GetStartQualifierClosed() []byte {
844 if x, ok := x.GetStartQualifier().(*ColumnRange_StartQualifierClosed); ok {
845 return x.StartQualifierClosed
846 }
847 return nil
848 }
849
850 func (x *ColumnRange) GetStartQualifierOpen() []byte {
851 if x, ok := x.GetStartQualifier().(*ColumnRange_StartQualifierOpen); ok {
852 return x.StartQualifierOpen
853 }
854 return nil
855 }
856
857 func (m *ColumnRange) GetEndQualifier() isColumnRange_EndQualifier {
858 if m != nil {
859 return m.EndQualifier
860 }
861 return nil
862 }
863
864 func (x *ColumnRange) GetEndQualifierClosed() []byte {
865 if x, ok := x.GetEndQualifier().(*ColumnRange_EndQualifierClosed); ok {
866 return x.EndQualifierClosed
867 }
868 return nil
869 }
870
871 func (x *ColumnRange) GetEndQualifierOpen() []byte {
872 if x, ok := x.GetEndQualifier().(*ColumnRange_EndQualifierOpen); ok {
873 return x.EndQualifierOpen
874 }
875 return nil
876 }
877
878 type isColumnRange_StartQualifier interface {
879 isColumnRange_StartQualifier()
880 }
881
882 type ColumnRange_StartQualifierClosed struct {
883 // Used when giving an inclusive lower bound for the range.
884 StartQualifierClosed []byte `protobuf:"bytes,2,opt,name=start_qualifier_closed,json=startQualifierClosed,proto3,oneof"`
885 }
886
887 type ColumnRange_StartQualifierOpen struct {
888 // Used when giving an exclusive lower bound for the range.
889 StartQualifierOpen []byte `protobuf:"bytes,3,opt,name=start_qualifier_open,json=startQualifierOpen,proto3,oneof"`
890 }
891
892 func (*ColumnRange_StartQualifierClosed) isColumnRange_StartQualifier() {}
893
894 func (*ColumnRange_StartQualifierOpen) isColumnRange_StartQualifier() {}
895
896 type isColumnRange_EndQualifier interface {
897 isColumnRange_EndQualifier()
898 }
899
900 type ColumnRange_EndQualifierClosed struct {
901 // Used when giving an inclusive upper bound for the range.
902 EndQualifierClosed []byte `protobuf:"bytes,4,opt,name=end_qualifier_closed,json=endQualifierClosed,proto3,oneof"`
903 }
904
905 type ColumnRange_EndQualifierOpen struct {
906 // Used when giving an exclusive upper bound for the range.
907 EndQualifierOpen []byte `protobuf:"bytes,5,opt,name=end_qualifier_open,json=endQualifierOpen,proto3,oneof"`
908 }
909
910 func (*ColumnRange_EndQualifierClosed) isColumnRange_EndQualifier() {}
911
912 func (*ColumnRange_EndQualifierOpen) isColumnRange_EndQualifier() {}
913
914 // Specified a contiguous range of microsecond timestamps.
915 type TimestampRange struct {
916 state protoimpl.MessageState
917 sizeCache protoimpl.SizeCache
918 unknownFields protoimpl.UnknownFields
919
920 // Inclusive lower bound. If left empty, interpreted as 0.
921 StartTimestampMicros int64 `protobuf:"varint,1,opt,name=start_timestamp_micros,json=startTimestampMicros,proto3" json:"start_timestamp_micros,omitempty"`
922 // Exclusive upper bound. If left empty, interpreted as infinity.
923 EndTimestampMicros int64 `protobuf:"varint,2,opt,name=end_timestamp_micros,json=endTimestampMicros,proto3" json:"end_timestamp_micros,omitempty"`
924 }
925
926 func (x *TimestampRange) Reset() {
927 *x = TimestampRange{}
928 mi := &file_google_bigtable_v2_data_proto_msgTypes[9]
929 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
930 ms.StoreMessageInfo(mi)
931 }
932
933 func (x *TimestampRange) String() string {
934 return protoimpl.X.MessageStringOf(x)
935 }
936
937 func (*TimestampRange) ProtoMessage() {}
938
939 func (x *TimestampRange) ProtoReflect() protoreflect.Message {
940 mi := &file_google_bigtable_v2_data_proto_msgTypes[9]
941 if x != nil {
942 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
943 if ms.LoadMessageInfo() == nil {
944 ms.StoreMessageInfo(mi)
945 }
946 return ms
947 }
948 return mi.MessageOf(x)
949 }
950
951 // Deprecated: Use TimestampRange.ProtoReflect.Descriptor instead.
952 func (*TimestampRange) Descriptor() ([]byte, []int) {
953 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{9}
954 }
955
956 func (x *TimestampRange) GetStartTimestampMicros() int64 {
957 if x != nil {
958 return x.StartTimestampMicros
959 }
960 return 0
961 }
962
963 func (x *TimestampRange) GetEndTimestampMicros() int64 {
964 if x != nil {
965 return x.EndTimestampMicros
966 }
967 return 0
968 }
969
970 // Specifies a contiguous range of raw byte values.
971 type ValueRange struct {
972 state protoimpl.MessageState
973 sizeCache protoimpl.SizeCache
974 unknownFields protoimpl.UnknownFields
975
976 // The value at which to start the range.
977 // If neither field is set, interpreted as the empty string, inclusive.
978 //
979 // Types that are assignable to StartValue:
980 //
981 // *ValueRange_StartValueClosed
982 // *ValueRange_StartValueOpen
983 StartValue isValueRange_StartValue `protobuf_oneof:"start_value"`
984 // The value at which to end the range.
985 // If neither field is set, interpreted as the infinite string, exclusive.
986 //
987 // Types that are assignable to EndValue:
988 //
989 // *ValueRange_EndValueClosed
990 // *ValueRange_EndValueOpen
991 EndValue isValueRange_EndValue `protobuf_oneof:"end_value"`
992 }
993
994 func (x *ValueRange) Reset() {
995 *x = ValueRange{}
996 mi := &file_google_bigtable_v2_data_proto_msgTypes[10]
997 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
998 ms.StoreMessageInfo(mi)
999 }
1000
1001 func (x *ValueRange) String() string {
1002 return protoimpl.X.MessageStringOf(x)
1003 }
1004
1005 func (*ValueRange) ProtoMessage() {}
1006
1007 func (x *ValueRange) ProtoReflect() protoreflect.Message {
1008 mi := &file_google_bigtable_v2_data_proto_msgTypes[10]
1009 if x != nil {
1010 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1011 if ms.LoadMessageInfo() == nil {
1012 ms.StoreMessageInfo(mi)
1013 }
1014 return ms
1015 }
1016 return mi.MessageOf(x)
1017 }
1018
1019 // Deprecated: Use ValueRange.ProtoReflect.Descriptor instead.
1020 func (*ValueRange) Descriptor() ([]byte, []int) {
1021 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{10}
1022 }
1023
1024 func (m *ValueRange) GetStartValue() isValueRange_StartValue {
1025 if m != nil {
1026 return m.StartValue
1027 }
1028 return nil
1029 }
1030
1031 func (x *ValueRange) GetStartValueClosed() []byte {
1032 if x, ok := x.GetStartValue().(*ValueRange_StartValueClosed); ok {
1033 return x.StartValueClosed
1034 }
1035 return nil
1036 }
1037
1038 func (x *ValueRange) GetStartValueOpen() []byte {
1039 if x, ok := x.GetStartValue().(*ValueRange_StartValueOpen); ok {
1040 return x.StartValueOpen
1041 }
1042 return nil
1043 }
1044
1045 func (m *ValueRange) GetEndValue() isValueRange_EndValue {
1046 if m != nil {
1047 return m.EndValue
1048 }
1049 return nil
1050 }
1051
1052 func (x *ValueRange) GetEndValueClosed() []byte {
1053 if x, ok := x.GetEndValue().(*ValueRange_EndValueClosed); ok {
1054 return x.EndValueClosed
1055 }
1056 return nil
1057 }
1058
1059 func (x *ValueRange) GetEndValueOpen() []byte {
1060 if x, ok := x.GetEndValue().(*ValueRange_EndValueOpen); ok {
1061 return x.EndValueOpen
1062 }
1063 return nil
1064 }
1065
1066 type isValueRange_StartValue interface {
1067 isValueRange_StartValue()
1068 }
1069
1070 type ValueRange_StartValueClosed struct {
1071 // Used when giving an inclusive lower bound for the range.
1072 StartValueClosed []byte `protobuf:"bytes,1,opt,name=start_value_closed,json=startValueClosed,proto3,oneof"`
1073 }
1074
1075 type ValueRange_StartValueOpen struct {
1076 // Used when giving an exclusive lower bound for the range.
1077 StartValueOpen []byte `protobuf:"bytes,2,opt,name=start_value_open,json=startValueOpen,proto3,oneof"`
1078 }
1079
1080 func (*ValueRange_StartValueClosed) isValueRange_StartValue() {}
1081
1082 func (*ValueRange_StartValueOpen) isValueRange_StartValue() {}
1083
1084 type isValueRange_EndValue interface {
1085 isValueRange_EndValue()
1086 }
1087
1088 type ValueRange_EndValueClosed struct {
1089 // Used when giving an inclusive upper bound for the range.
1090 EndValueClosed []byte `protobuf:"bytes,3,opt,name=end_value_closed,json=endValueClosed,proto3,oneof"`
1091 }
1092
1093 type ValueRange_EndValueOpen struct {
1094 // Used when giving an exclusive upper bound for the range.
1095 EndValueOpen []byte `protobuf:"bytes,4,opt,name=end_value_open,json=endValueOpen,proto3,oneof"`
1096 }
1097
1098 func (*ValueRange_EndValueClosed) isValueRange_EndValue() {}
1099
1100 func (*ValueRange_EndValueOpen) isValueRange_EndValue() {}
1101
1102 // Takes a row as input and produces an alternate view of the row based on
1103 // specified rules. For example, a RowFilter might trim down a row to include
1104 // just the cells from columns matching a given regular expression, or might
1105 // return all the cells of a row but not their values. More complicated filters
1106 // can be composed out of these components to express requests such as, "within
1107 // every column of a particular family, give just the two most recent cells
1108 // which are older than timestamp X."
1109 //
1110 // There are two broad categories of RowFilters (true filters and transformers),
1111 // as well as two ways to compose simple filters into more complex ones
1112 // (chains and interleaves). They work as follows:
1113 //
1114 // * True filters alter the input row by excluding some of its cells wholesale
1115 // from the output row. An example of a true filter is the `value_regex_filter`,
1116 // which excludes cells whose values don't match the specified pattern. All
1117 // regex true filters use RE2 syntax (https://github.com/google/re2/wiki/Syntax)
1118 // in raw byte mode (RE2::Latin1), and are evaluated as full matches. An
1119 // important point to keep in mind is that `RE2(.)` is equivalent by default to
1120 // `RE2([^\n])`, meaning that it does not match newlines. When attempting to
1121 // match an arbitrary byte, you should therefore use the escape sequence `\C`,
1122 // which may need to be further escaped as `\\C` in your client language.
1123 //
1124 // * Transformers alter the input row by changing the values of some of its
1125 // cells in the output, without excluding them completely. Currently, the only
1126 // supported transformer is the `strip_value_transformer`, which replaces every
1127 // cell's value with the empty string.
1128 //
1129 // * Chains and interleaves are described in more detail in the
1130 // RowFilter.Chain and RowFilter.Interleave documentation.
1131 //
1132 // The total serialized size of a RowFilter message must not
1133 // exceed 20480 bytes, and RowFilters may not be nested within each other
1134 // (in Chains or Interleaves) to a depth of more than 20.
1135 type RowFilter struct {
1136 state protoimpl.MessageState
1137 sizeCache protoimpl.SizeCache
1138 unknownFields protoimpl.UnknownFields
1139
1140 // Which of the possible RowFilter types to apply. If none are set, this
1141 // RowFilter returns all cells in the input row.
1142 //
1143 // Types that are assignable to Filter:
1144 //
1145 // *RowFilter_Chain_
1146 // *RowFilter_Interleave_
1147 // *RowFilter_Condition_
1148 // *RowFilter_Sink
1149 // *RowFilter_PassAllFilter
1150 // *RowFilter_BlockAllFilter
1151 // *RowFilter_RowKeyRegexFilter
1152 // *RowFilter_RowSampleFilter
1153 // *RowFilter_FamilyNameRegexFilter
1154 // *RowFilter_ColumnQualifierRegexFilter
1155 // *RowFilter_ColumnRangeFilter
1156 // *RowFilter_TimestampRangeFilter
1157 // *RowFilter_ValueRegexFilter
1158 // *RowFilter_ValueRangeFilter
1159 // *RowFilter_CellsPerRowOffsetFilter
1160 // *RowFilter_CellsPerRowLimitFilter
1161 // *RowFilter_CellsPerColumnLimitFilter
1162 // *RowFilter_StripValueTransformer
1163 // *RowFilter_ApplyLabelTransformer
1164 Filter isRowFilter_Filter `protobuf_oneof:"filter"`
1165 }
1166
1167 func (x *RowFilter) Reset() {
1168 *x = RowFilter{}
1169 mi := &file_google_bigtable_v2_data_proto_msgTypes[11]
1170 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1171 ms.StoreMessageInfo(mi)
1172 }
1173
1174 func (x *RowFilter) String() string {
1175 return protoimpl.X.MessageStringOf(x)
1176 }
1177
1178 func (*RowFilter) ProtoMessage() {}
1179
1180 func (x *RowFilter) ProtoReflect() protoreflect.Message {
1181 mi := &file_google_bigtable_v2_data_proto_msgTypes[11]
1182 if x != nil {
1183 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1184 if ms.LoadMessageInfo() == nil {
1185 ms.StoreMessageInfo(mi)
1186 }
1187 return ms
1188 }
1189 return mi.MessageOf(x)
1190 }
1191
1192 // Deprecated: Use RowFilter.ProtoReflect.Descriptor instead.
1193 func (*RowFilter) Descriptor() ([]byte, []int) {
1194 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{11}
1195 }
1196
1197 func (m *RowFilter) GetFilter() isRowFilter_Filter {
1198 if m != nil {
1199 return m.Filter
1200 }
1201 return nil
1202 }
1203
1204 func (x *RowFilter) GetChain() *RowFilter_Chain {
1205 if x, ok := x.GetFilter().(*RowFilter_Chain_); ok {
1206 return x.Chain
1207 }
1208 return nil
1209 }
1210
1211 func (x *RowFilter) GetInterleave() *RowFilter_Interleave {
1212 if x, ok := x.GetFilter().(*RowFilter_Interleave_); ok {
1213 return x.Interleave
1214 }
1215 return nil
1216 }
1217
1218 func (x *RowFilter) GetCondition() *RowFilter_Condition {
1219 if x, ok := x.GetFilter().(*RowFilter_Condition_); ok {
1220 return x.Condition
1221 }
1222 return nil
1223 }
1224
1225 func (x *RowFilter) GetSink() bool {
1226 if x, ok := x.GetFilter().(*RowFilter_Sink); ok {
1227 return x.Sink
1228 }
1229 return false
1230 }
1231
1232 func (x *RowFilter) GetPassAllFilter() bool {
1233 if x, ok := x.GetFilter().(*RowFilter_PassAllFilter); ok {
1234 return x.PassAllFilter
1235 }
1236 return false
1237 }
1238
1239 func (x *RowFilter) GetBlockAllFilter() bool {
1240 if x, ok := x.GetFilter().(*RowFilter_BlockAllFilter); ok {
1241 return x.BlockAllFilter
1242 }
1243 return false
1244 }
1245
1246 func (x *RowFilter) GetRowKeyRegexFilter() []byte {
1247 if x, ok := x.GetFilter().(*RowFilter_RowKeyRegexFilter); ok {
1248 return x.RowKeyRegexFilter
1249 }
1250 return nil
1251 }
1252
1253 func (x *RowFilter) GetRowSampleFilter() float64 {
1254 if x, ok := x.GetFilter().(*RowFilter_RowSampleFilter); ok {
1255 return x.RowSampleFilter
1256 }
1257 return 0
1258 }
1259
1260 func (x *RowFilter) GetFamilyNameRegexFilter() string {
1261 if x, ok := x.GetFilter().(*RowFilter_FamilyNameRegexFilter); ok {
1262 return x.FamilyNameRegexFilter
1263 }
1264 return ""
1265 }
1266
1267 func (x *RowFilter) GetColumnQualifierRegexFilter() []byte {
1268 if x, ok := x.GetFilter().(*RowFilter_ColumnQualifierRegexFilter); ok {
1269 return x.ColumnQualifierRegexFilter
1270 }
1271 return nil
1272 }
1273
1274 func (x *RowFilter) GetColumnRangeFilter() *ColumnRange {
1275 if x, ok := x.GetFilter().(*RowFilter_ColumnRangeFilter); ok {
1276 return x.ColumnRangeFilter
1277 }
1278 return nil
1279 }
1280
1281 func (x *RowFilter) GetTimestampRangeFilter() *TimestampRange {
1282 if x, ok := x.GetFilter().(*RowFilter_TimestampRangeFilter); ok {
1283 return x.TimestampRangeFilter
1284 }
1285 return nil
1286 }
1287
1288 func (x *RowFilter) GetValueRegexFilter() []byte {
1289 if x, ok := x.GetFilter().(*RowFilter_ValueRegexFilter); ok {
1290 return x.ValueRegexFilter
1291 }
1292 return nil
1293 }
1294
1295 func (x *RowFilter) GetValueRangeFilter() *ValueRange {
1296 if x, ok := x.GetFilter().(*RowFilter_ValueRangeFilter); ok {
1297 return x.ValueRangeFilter
1298 }
1299 return nil
1300 }
1301
1302 func (x *RowFilter) GetCellsPerRowOffsetFilter() int32 {
1303 if x, ok := x.GetFilter().(*RowFilter_CellsPerRowOffsetFilter); ok {
1304 return x.CellsPerRowOffsetFilter
1305 }
1306 return 0
1307 }
1308
1309 func (x *RowFilter) GetCellsPerRowLimitFilter() int32 {
1310 if x, ok := x.GetFilter().(*RowFilter_CellsPerRowLimitFilter); ok {
1311 return x.CellsPerRowLimitFilter
1312 }
1313 return 0
1314 }
1315
1316 func (x *RowFilter) GetCellsPerColumnLimitFilter() int32 {
1317 if x, ok := x.GetFilter().(*RowFilter_CellsPerColumnLimitFilter); ok {
1318 return x.CellsPerColumnLimitFilter
1319 }
1320 return 0
1321 }
1322
1323 func (x *RowFilter) GetStripValueTransformer() bool {
1324 if x, ok := x.GetFilter().(*RowFilter_StripValueTransformer); ok {
1325 return x.StripValueTransformer
1326 }
1327 return false
1328 }
1329
1330 func (x *RowFilter) GetApplyLabelTransformer() string {
1331 if x, ok := x.GetFilter().(*RowFilter_ApplyLabelTransformer); ok {
1332 return x.ApplyLabelTransformer
1333 }
1334 return ""
1335 }
1336
1337 type isRowFilter_Filter interface {
1338 isRowFilter_Filter()
1339 }
1340
1341 type RowFilter_Chain_ struct {
1342 // Applies several RowFilters to the data in sequence, progressively
1343 // narrowing the results.
1344 Chain *RowFilter_Chain `protobuf:"bytes,1,opt,name=chain,proto3,oneof"`
1345 }
1346
1347 type RowFilter_Interleave_ struct {
1348 // Applies several RowFilters to the data in parallel and combines the
1349 // results.
1350 Interleave *RowFilter_Interleave `protobuf:"bytes,2,opt,name=interleave,proto3,oneof"`
1351 }
1352
1353 type RowFilter_Condition_ struct {
1354 // Applies one of two possible RowFilters to the data based on the output of
1355 // a predicate RowFilter.
1356 Condition *RowFilter_Condition `protobuf:"bytes,3,opt,name=condition,proto3,oneof"`
1357 }
1358
1359 type RowFilter_Sink struct {
1360 // ADVANCED USE ONLY.
1361 // Hook for introspection into the RowFilter. Outputs all cells directly to
1362 // the output of the read rather than to any parent filter. Consider the
1363 // following example:
1364 //
1365 // Chain(
1366 // FamilyRegex("A"),
1367 // Interleave(
1368 // All(),
1369 // Chain(Label("foo"), Sink())
1370 // ),
1371 // QualifierRegex("B")
1372 // )
1373 //
1374 // A,A,1,w
1375 // A,B,2,x
1376 // B,B,4,z
1377 // |
1378 // FamilyRegex("A")
1379 // |
1380 // A,A,1,w
1381 // A,B,2,x
1382 // |
1383 // +------------+-------------+
1384 // | |
1385 // All() Label(foo)
1386 // | |
1387 // A,A,1,w A,A,1,w,labels:[foo]
1388 // A,B,2,x A,B,2,x,labels:[foo]
1389 // | |
1390 // | Sink() --------------+
1391 // | | |
1392 // +------------+ x------+ A,A,1,w,labels:[foo]
1393 // | A,B,2,x,labels:[foo]
1394 // A,A,1,w |
1395 // A,B,2,x |
1396 // | |
1397 // QualifierRegex("B") |
1398 // | |
1399 // A,B,2,x |
1400 // | |
1401 // +--------------------------------+
1402 // |
1403 // A,A,1,w,labels:[foo]
1404 // A,B,2,x,labels:[foo] // could be switched
1405 // A,B,2,x // could be switched
1406 //
1407 // Despite being excluded by the qualifier filter, a copy of every cell
1408 // that reaches the sink is present in the final result.
1409 //
1410 // As with an [Interleave][google.bigtable.v2.RowFilter.Interleave],
1411 // duplicate cells are possible, and appear in an unspecified mutual order.
1412 // In this case we have a duplicate with column "A:B" and timestamp 2,
1413 // because one copy passed through the all filter while the other was
1414 // passed through the label and sink. Note that one copy has label "foo",
1415 // while the other does not.
1416 //
1417 // Cannot be used within the `predicate_filter`, `true_filter`, or
1418 // `false_filter` of a [Condition][google.bigtable.v2.RowFilter.Condition].
1419 Sink bool `protobuf:"varint,16,opt,name=sink,proto3,oneof"`
1420 }
1421
1422 type RowFilter_PassAllFilter struct {
1423 // Matches all cells, regardless of input. Functionally equivalent to
1424 // leaving `filter` unset, but included for completeness.
1425 PassAllFilter bool `protobuf:"varint,17,opt,name=pass_all_filter,json=passAllFilter,proto3,oneof"`
1426 }
1427
1428 type RowFilter_BlockAllFilter struct {
1429 // Does not match any cells, regardless of input. Useful for temporarily
1430 // disabling just part of a filter.
1431 BlockAllFilter bool `protobuf:"varint,18,opt,name=block_all_filter,json=blockAllFilter,proto3,oneof"`
1432 }
1433
1434 type RowFilter_RowKeyRegexFilter struct {
1435 // Matches only cells from rows whose keys satisfy the given RE2 regex. In
1436 // other words, passes through the entire row when the key matches, and
1437 // otherwise produces an empty row.
1438 // Note that, since row keys can contain arbitrary bytes, the `\C` escape
1439 // sequence must be used if a true wildcard is desired. The `.` character
1440 // will not match the new line character `\n`, which may be present in a
1441 // binary key.
1442 RowKeyRegexFilter []byte `protobuf:"bytes,4,opt,name=row_key_regex_filter,json=rowKeyRegexFilter,proto3,oneof"`
1443 }
1444
1445 type RowFilter_RowSampleFilter struct {
1446 // Matches all cells from a row with probability p, and matches no cells
1447 // from the row with probability 1-p.
1448 RowSampleFilter float64 `protobuf:"fixed64,14,opt,name=row_sample_filter,json=rowSampleFilter,proto3,oneof"`
1449 }
1450
1451 type RowFilter_FamilyNameRegexFilter struct {
1452 // Matches only cells from columns whose families satisfy the given RE2
1453 // regex. For technical reasons, the regex must not contain the `:`
1454 // character, even if it is not being used as a literal.
1455 // Note that, since column families cannot contain the new line character
1456 // `\n`, it is sufficient to use `.` as a full wildcard when matching
1457 // column family names.
1458 FamilyNameRegexFilter string `protobuf:"bytes,5,opt,name=family_name_regex_filter,json=familyNameRegexFilter,proto3,oneof"`
1459 }
1460
1461 type RowFilter_ColumnQualifierRegexFilter struct {
1462 // Matches only cells from columns whose qualifiers satisfy the given RE2
1463 // regex.
1464 // Note that, since column qualifiers can contain arbitrary bytes, the `\C`
1465 // escape sequence must be used if a true wildcard is desired. The `.`
1466 // character will not match the new line character `\n`, which may be
1467 // present in a binary qualifier.
1468 ColumnQualifierRegexFilter []byte `protobuf:"bytes,6,opt,name=column_qualifier_regex_filter,json=columnQualifierRegexFilter,proto3,oneof"`
1469 }
1470
1471 type RowFilter_ColumnRangeFilter struct {
1472 // Matches only cells from columns within the given range.
1473 ColumnRangeFilter *ColumnRange `protobuf:"bytes,7,opt,name=column_range_filter,json=columnRangeFilter,proto3,oneof"`
1474 }
1475
1476 type RowFilter_TimestampRangeFilter struct {
1477 // Matches only cells with timestamps within the given range.
1478 TimestampRangeFilter *TimestampRange `protobuf:"bytes,8,opt,name=timestamp_range_filter,json=timestampRangeFilter,proto3,oneof"`
1479 }
1480
1481 type RowFilter_ValueRegexFilter struct {
1482 // Matches only cells with values that satisfy the given regular expression.
1483 // Note that, since cell values can contain arbitrary bytes, the `\C` escape
1484 // sequence must be used if a true wildcard is desired. The `.` character
1485 // will not match the new line character `\n`, which may be present in a
1486 // binary value.
1487 ValueRegexFilter []byte `protobuf:"bytes,9,opt,name=value_regex_filter,json=valueRegexFilter,proto3,oneof"`
1488 }
1489
1490 type RowFilter_ValueRangeFilter struct {
1491 // Matches only cells with values that fall within the given range.
1492 ValueRangeFilter *ValueRange `protobuf:"bytes,15,opt,name=value_range_filter,json=valueRangeFilter,proto3,oneof"`
1493 }
1494
1495 type RowFilter_CellsPerRowOffsetFilter struct {
1496 // Skips the first N cells of each row, matching all subsequent cells.
1497 // If duplicate cells are present, as is possible when using an Interleave,
1498 // each copy of the cell is counted separately.
1499 CellsPerRowOffsetFilter int32 `protobuf:"varint,10,opt,name=cells_per_row_offset_filter,json=cellsPerRowOffsetFilter,proto3,oneof"`
1500 }
1501
1502 type RowFilter_CellsPerRowLimitFilter struct {
1503 // Matches only the first N cells of each row.
1504 // If duplicate cells are present, as is possible when using an Interleave,
1505 // each copy of the cell is counted separately.
1506 CellsPerRowLimitFilter int32 `protobuf:"varint,11,opt,name=cells_per_row_limit_filter,json=cellsPerRowLimitFilter,proto3,oneof"`
1507 }
1508
1509 type RowFilter_CellsPerColumnLimitFilter struct {
1510 // Matches only the most recent N cells within each column. For example,
1511 // if N=2, this filter would match column `foo:bar` at timestamps 10 and 9,
1512 // skip all earlier cells in `foo:bar`, and then begin matching again in
1513 // column `foo:bar2`.
1514 // If duplicate cells are present, as is possible when using an Interleave,
1515 // each copy of the cell is counted separately.
1516 CellsPerColumnLimitFilter int32 `protobuf:"varint,12,opt,name=cells_per_column_limit_filter,json=cellsPerColumnLimitFilter,proto3,oneof"`
1517 }
1518
1519 type RowFilter_StripValueTransformer struct {
1520 // Replaces each cell's value with the empty string.
1521 StripValueTransformer bool `protobuf:"varint,13,opt,name=strip_value_transformer,json=stripValueTransformer,proto3,oneof"`
1522 }
1523
1524 type RowFilter_ApplyLabelTransformer struct {
1525 // Applies the given label to all cells in the output row. This allows
1526 // the client to determine which results were produced from which part of
1527 // the filter.
1528 //
1529 // Values must be at most 15 characters in length, and match the RE2
1530 // pattern `[a-z0-9\\-]+`
1531 //
1532 // Due to a technical limitation, it is not currently possible to apply
1533 // multiple labels to a cell. As a result, a Chain may have no more than
1534 // one sub-filter which contains a `apply_label_transformer`. It is okay for
1535 // an Interleave to contain multiple `apply_label_transformers`, as they
1536 // will be applied to separate copies of the input. This may be relaxed in
1537 // the future.
1538 ApplyLabelTransformer string `protobuf:"bytes,19,opt,name=apply_label_transformer,json=applyLabelTransformer,proto3,oneof"`
1539 }
1540
1541 func (*RowFilter_Chain_) isRowFilter_Filter() {}
1542
1543 func (*RowFilter_Interleave_) isRowFilter_Filter() {}
1544
1545 func (*RowFilter_Condition_) isRowFilter_Filter() {}
1546
1547 func (*RowFilter_Sink) isRowFilter_Filter() {}
1548
1549 func (*RowFilter_PassAllFilter) isRowFilter_Filter() {}
1550
1551 func (*RowFilter_BlockAllFilter) isRowFilter_Filter() {}
1552
1553 func (*RowFilter_RowKeyRegexFilter) isRowFilter_Filter() {}
1554
1555 func (*RowFilter_RowSampleFilter) isRowFilter_Filter() {}
1556
1557 func (*RowFilter_FamilyNameRegexFilter) isRowFilter_Filter() {}
1558
1559 func (*RowFilter_ColumnQualifierRegexFilter) isRowFilter_Filter() {}
1560
1561 func (*RowFilter_ColumnRangeFilter) isRowFilter_Filter() {}
1562
1563 func (*RowFilter_TimestampRangeFilter) isRowFilter_Filter() {}
1564
1565 func (*RowFilter_ValueRegexFilter) isRowFilter_Filter() {}
1566
1567 func (*RowFilter_ValueRangeFilter) isRowFilter_Filter() {}
1568
1569 func (*RowFilter_CellsPerRowOffsetFilter) isRowFilter_Filter() {}
1570
1571 func (*RowFilter_CellsPerRowLimitFilter) isRowFilter_Filter() {}
1572
1573 func (*RowFilter_CellsPerColumnLimitFilter) isRowFilter_Filter() {}
1574
1575 func (*RowFilter_StripValueTransformer) isRowFilter_Filter() {}
1576
1577 func (*RowFilter_ApplyLabelTransformer) isRowFilter_Filter() {}
1578
1579 // Specifies a particular change to be made to the contents of a row.
1580 type Mutation struct {
1581 state protoimpl.MessageState
1582 sizeCache protoimpl.SizeCache
1583 unknownFields protoimpl.UnknownFields
1584
1585 // Which of the possible Mutation types to apply.
1586 //
1587 // Types that are assignable to Mutation:
1588 //
1589 // *Mutation_SetCell_
1590 // *Mutation_AddToCell_
1591 // *Mutation_MergeToCell_
1592 // *Mutation_DeleteFromColumn_
1593 // *Mutation_DeleteFromFamily_
1594 // *Mutation_DeleteFromRow_
1595 Mutation isMutation_Mutation `protobuf_oneof:"mutation"`
1596 }
1597
1598 func (x *Mutation) Reset() {
1599 *x = Mutation{}
1600 mi := &file_google_bigtable_v2_data_proto_msgTypes[12]
1601 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1602 ms.StoreMessageInfo(mi)
1603 }
1604
1605 func (x *Mutation) String() string {
1606 return protoimpl.X.MessageStringOf(x)
1607 }
1608
1609 func (*Mutation) ProtoMessage() {}
1610
1611 func (x *Mutation) ProtoReflect() protoreflect.Message {
1612 mi := &file_google_bigtable_v2_data_proto_msgTypes[12]
1613 if x != nil {
1614 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1615 if ms.LoadMessageInfo() == nil {
1616 ms.StoreMessageInfo(mi)
1617 }
1618 return ms
1619 }
1620 return mi.MessageOf(x)
1621 }
1622
1623 // Deprecated: Use Mutation.ProtoReflect.Descriptor instead.
1624 func (*Mutation) Descriptor() ([]byte, []int) {
1625 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{12}
1626 }
1627
1628 func (m *Mutation) GetMutation() isMutation_Mutation {
1629 if m != nil {
1630 return m.Mutation
1631 }
1632 return nil
1633 }
1634
1635 func (x *Mutation) GetSetCell() *Mutation_SetCell {
1636 if x, ok := x.GetMutation().(*Mutation_SetCell_); ok {
1637 return x.SetCell
1638 }
1639 return nil
1640 }
1641
1642 func (x *Mutation) GetAddToCell() *Mutation_AddToCell {
1643 if x, ok := x.GetMutation().(*Mutation_AddToCell_); ok {
1644 return x.AddToCell
1645 }
1646 return nil
1647 }
1648
1649 func (x *Mutation) GetMergeToCell() *Mutation_MergeToCell {
1650 if x, ok := x.GetMutation().(*Mutation_MergeToCell_); ok {
1651 return x.MergeToCell
1652 }
1653 return nil
1654 }
1655
1656 func (x *Mutation) GetDeleteFromColumn() *Mutation_DeleteFromColumn {
1657 if x, ok := x.GetMutation().(*Mutation_DeleteFromColumn_); ok {
1658 return x.DeleteFromColumn
1659 }
1660 return nil
1661 }
1662
1663 func (x *Mutation) GetDeleteFromFamily() *Mutation_DeleteFromFamily {
1664 if x, ok := x.GetMutation().(*Mutation_DeleteFromFamily_); ok {
1665 return x.DeleteFromFamily
1666 }
1667 return nil
1668 }
1669
1670 func (x *Mutation) GetDeleteFromRow() *Mutation_DeleteFromRow {
1671 if x, ok := x.GetMutation().(*Mutation_DeleteFromRow_); ok {
1672 return x.DeleteFromRow
1673 }
1674 return nil
1675 }
1676
1677 type isMutation_Mutation interface {
1678 isMutation_Mutation()
1679 }
1680
1681 type Mutation_SetCell_ struct {
1682 // Set a cell's value.
1683 SetCell *Mutation_SetCell `protobuf:"bytes,1,opt,name=set_cell,json=setCell,proto3,oneof"`
1684 }
1685
1686 type Mutation_AddToCell_ struct {
1687 // Incrementally updates an `Aggregate` cell.
1688 AddToCell *Mutation_AddToCell `protobuf:"bytes,5,opt,name=add_to_cell,json=addToCell,proto3,oneof"`
1689 }
1690
1691 type Mutation_MergeToCell_ struct {
1692 // Merges accumulated state to an `Aggregate` cell.
1693 MergeToCell *Mutation_MergeToCell `protobuf:"bytes,6,opt,name=merge_to_cell,json=mergeToCell,proto3,oneof"`
1694 }
1695
1696 type Mutation_DeleteFromColumn_ struct {
1697 // Deletes cells from a column.
1698 DeleteFromColumn *Mutation_DeleteFromColumn `protobuf:"bytes,2,opt,name=delete_from_column,json=deleteFromColumn,proto3,oneof"`
1699 }
1700
1701 type Mutation_DeleteFromFamily_ struct {
1702 // Deletes cells from a column family.
1703 DeleteFromFamily *Mutation_DeleteFromFamily `protobuf:"bytes,3,opt,name=delete_from_family,json=deleteFromFamily,proto3,oneof"`
1704 }
1705
1706 type Mutation_DeleteFromRow_ struct {
1707 // Deletes cells from the entire row.
1708 DeleteFromRow *Mutation_DeleteFromRow `protobuf:"bytes,4,opt,name=delete_from_row,json=deleteFromRow,proto3,oneof"`
1709 }
1710
1711 func (*Mutation_SetCell_) isMutation_Mutation() {}
1712
1713 func (*Mutation_AddToCell_) isMutation_Mutation() {}
1714
1715 func (*Mutation_MergeToCell_) isMutation_Mutation() {}
1716
1717 func (*Mutation_DeleteFromColumn_) isMutation_Mutation() {}
1718
1719 func (*Mutation_DeleteFromFamily_) isMutation_Mutation() {}
1720
1721 func (*Mutation_DeleteFromRow_) isMutation_Mutation() {}
1722
1723 // Specifies an atomic read/modify/write operation on the latest value of the
1724 // specified column.
1725 type ReadModifyWriteRule struct {
1726 state protoimpl.MessageState
1727 sizeCache protoimpl.SizeCache
1728 unknownFields protoimpl.UnknownFields
1729
1730 // The name of the family to which the read/modify/write should be applied.
1731 // Must match `[-_.a-zA-Z0-9]+`
1732 FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
1733 // The qualifier of the column to which the read/modify/write should be
1734 // applied.
1735 // Can be any byte string, including the empty string.
1736 ColumnQualifier []byte `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier,proto3" json:"column_qualifier,omitempty"`
1737 // The rule used to determine the column's new latest value from its current
1738 // latest value.
1739 //
1740 // Types that are assignable to Rule:
1741 //
1742 // *ReadModifyWriteRule_AppendValue
1743 // *ReadModifyWriteRule_IncrementAmount
1744 Rule isReadModifyWriteRule_Rule `protobuf_oneof:"rule"`
1745 }
1746
1747 func (x *ReadModifyWriteRule) Reset() {
1748 *x = ReadModifyWriteRule{}
1749 mi := &file_google_bigtable_v2_data_proto_msgTypes[13]
1750 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1751 ms.StoreMessageInfo(mi)
1752 }
1753
1754 func (x *ReadModifyWriteRule) String() string {
1755 return protoimpl.X.MessageStringOf(x)
1756 }
1757
1758 func (*ReadModifyWriteRule) ProtoMessage() {}
1759
1760 func (x *ReadModifyWriteRule) ProtoReflect() protoreflect.Message {
1761 mi := &file_google_bigtable_v2_data_proto_msgTypes[13]
1762 if x != nil {
1763 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1764 if ms.LoadMessageInfo() == nil {
1765 ms.StoreMessageInfo(mi)
1766 }
1767 return ms
1768 }
1769 return mi.MessageOf(x)
1770 }
1771
1772 // Deprecated: Use ReadModifyWriteRule.ProtoReflect.Descriptor instead.
1773 func (*ReadModifyWriteRule) Descriptor() ([]byte, []int) {
1774 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{13}
1775 }
1776
1777 func (x *ReadModifyWriteRule) GetFamilyName() string {
1778 if x != nil {
1779 return x.FamilyName
1780 }
1781 return ""
1782 }
1783
1784 func (x *ReadModifyWriteRule) GetColumnQualifier() []byte {
1785 if x != nil {
1786 return x.ColumnQualifier
1787 }
1788 return nil
1789 }
1790
1791 func (m *ReadModifyWriteRule) GetRule() isReadModifyWriteRule_Rule {
1792 if m != nil {
1793 return m.Rule
1794 }
1795 return nil
1796 }
1797
1798 func (x *ReadModifyWriteRule) GetAppendValue() []byte {
1799 if x, ok := x.GetRule().(*ReadModifyWriteRule_AppendValue); ok {
1800 return x.AppendValue
1801 }
1802 return nil
1803 }
1804
1805 func (x *ReadModifyWriteRule) GetIncrementAmount() int64 {
1806 if x, ok := x.GetRule().(*ReadModifyWriteRule_IncrementAmount); ok {
1807 return x.IncrementAmount
1808 }
1809 return 0
1810 }
1811
1812 type isReadModifyWriteRule_Rule interface {
1813 isReadModifyWriteRule_Rule()
1814 }
1815
1816 type ReadModifyWriteRule_AppendValue struct {
1817 // Rule specifying that `append_value` be appended to the existing value.
1818 // If the targeted cell is unset, it will be treated as containing the
1819 // empty string.
1820 AppendValue []byte `protobuf:"bytes,3,opt,name=append_value,json=appendValue,proto3,oneof"`
1821 }
1822
1823 type ReadModifyWriteRule_IncrementAmount struct {
1824 // Rule specifying that `increment_amount` be added to the existing value.
1825 // If the targeted cell is unset, it will be treated as containing a zero.
1826 // Otherwise, the targeted cell must contain an 8-byte value (interpreted
1827 // as a 64-bit big-endian signed integer), or the entire request will fail.
1828 IncrementAmount int64 `protobuf:"varint,4,opt,name=increment_amount,json=incrementAmount,proto3,oneof"`
1829 }
1830
1831 func (*ReadModifyWriteRule_AppendValue) isReadModifyWriteRule_Rule() {}
1832
1833 func (*ReadModifyWriteRule_IncrementAmount) isReadModifyWriteRule_Rule() {}
1834
1835 // NOTE: This API is intended to be used by Apache Beam BigtableIO.
1836 // A partition of a change stream.
1837 type StreamPartition struct {
1838 state protoimpl.MessageState
1839 sizeCache protoimpl.SizeCache
1840 unknownFields protoimpl.UnknownFields
1841
1842 // The row range covered by this partition and is specified by
1843 // [`start_key_closed`, `end_key_open`).
1844 RowRange *RowRange `protobuf:"bytes,1,opt,name=row_range,json=rowRange,proto3" json:"row_range,omitempty"`
1845 }
1846
1847 func (x *StreamPartition) Reset() {
1848 *x = StreamPartition{}
1849 mi := &file_google_bigtable_v2_data_proto_msgTypes[14]
1850 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1851 ms.StoreMessageInfo(mi)
1852 }
1853
1854 func (x *StreamPartition) String() string {
1855 return protoimpl.X.MessageStringOf(x)
1856 }
1857
1858 func (*StreamPartition) ProtoMessage() {}
1859
1860 func (x *StreamPartition) ProtoReflect() protoreflect.Message {
1861 mi := &file_google_bigtable_v2_data_proto_msgTypes[14]
1862 if x != nil {
1863 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1864 if ms.LoadMessageInfo() == nil {
1865 ms.StoreMessageInfo(mi)
1866 }
1867 return ms
1868 }
1869 return mi.MessageOf(x)
1870 }
1871
1872 // Deprecated: Use StreamPartition.ProtoReflect.Descriptor instead.
1873 func (*StreamPartition) Descriptor() ([]byte, []int) {
1874 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{14}
1875 }
1876
1877 func (x *StreamPartition) GetRowRange() *RowRange {
1878 if x != nil {
1879 return x.RowRange
1880 }
1881 return nil
1882 }
1883
1884 // NOTE: This API is intended to be used by Apache Beam BigtableIO.
1885 // The information required to continue reading the data from multiple
1886 // `StreamPartitions` from where a previous read left off.
1887 type StreamContinuationTokens struct {
1888 state protoimpl.MessageState
1889 sizeCache protoimpl.SizeCache
1890 unknownFields protoimpl.UnknownFields
1891
1892 // List of continuation tokens.
1893 Tokens []*StreamContinuationToken `protobuf:"bytes,1,rep,name=tokens,proto3" json:"tokens,omitempty"`
1894 }
1895
1896 func (x *StreamContinuationTokens) Reset() {
1897 *x = StreamContinuationTokens{}
1898 mi := &file_google_bigtable_v2_data_proto_msgTypes[15]
1899 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1900 ms.StoreMessageInfo(mi)
1901 }
1902
1903 func (x *StreamContinuationTokens) String() string {
1904 return protoimpl.X.MessageStringOf(x)
1905 }
1906
1907 func (*StreamContinuationTokens) ProtoMessage() {}
1908
1909 func (x *StreamContinuationTokens) ProtoReflect() protoreflect.Message {
1910 mi := &file_google_bigtable_v2_data_proto_msgTypes[15]
1911 if x != nil {
1912 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1913 if ms.LoadMessageInfo() == nil {
1914 ms.StoreMessageInfo(mi)
1915 }
1916 return ms
1917 }
1918 return mi.MessageOf(x)
1919 }
1920
1921 // Deprecated: Use StreamContinuationTokens.ProtoReflect.Descriptor instead.
1922 func (*StreamContinuationTokens) Descriptor() ([]byte, []int) {
1923 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{15}
1924 }
1925
1926 func (x *StreamContinuationTokens) GetTokens() []*StreamContinuationToken {
1927 if x != nil {
1928 return x.Tokens
1929 }
1930 return nil
1931 }
1932
1933 // NOTE: This API is intended to be used by Apache Beam BigtableIO.
1934 // The information required to continue reading the data from a
1935 // `StreamPartition` from where a previous read left off.
1936 type StreamContinuationToken struct {
1937 state protoimpl.MessageState
1938 sizeCache protoimpl.SizeCache
1939 unknownFields protoimpl.UnknownFields
1940
1941 // The partition that this token applies to.
1942 Partition *StreamPartition `protobuf:"bytes,1,opt,name=partition,proto3" json:"partition,omitempty"`
1943 // An encoded position in the stream to restart reading from.
1944 Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"`
1945 }
1946
1947 func (x *StreamContinuationToken) Reset() {
1948 *x = StreamContinuationToken{}
1949 mi := &file_google_bigtable_v2_data_proto_msgTypes[16]
1950 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1951 ms.StoreMessageInfo(mi)
1952 }
1953
1954 func (x *StreamContinuationToken) String() string {
1955 return protoimpl.X.MessageStringOf(x)
1956 }
1957
1958 func (*StreamContinuationToken) ProtoMessage() {}
1959
1960 func (x *StreamContinuationToken) ProtoReflect() protoreflect.Message {
1961 mi := &file_google_bigtable_v2_data_proto_msgTypes[16]
1962 if x != nil {
1963 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1964 if ms.LoadMessageInfo() == nil {
1965 ms.StoreMessageInfo(mi)
1966 }
1967 return ms
1968 }
1969 return mi.MessageOf(x)
1970 }
1971
1972 // Deprecated: Use StreamContinuationToken.ProtoReflect.Descriptor instead.
1973 func (*StreamContinuationToken) Descriptor() ([]byte, []int) {
1974 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{16}
1975 }
1976
1977 func (x *StreamContinuationToken) GetPartition() *StreamPartition {
1978 if x != nil {
1979 return x.Partition
1980 }
1981 return nil
1982 }
1983
1984 func (x *StreamContinuationToken) GetToken() string {
1985 if x != nil {
1986 return x.Token
1987 }
1988 return ""
1989 }
1990
1991 // Protocol buffers format descriptor, as described by Messages ProtoSchema and
1992 // ProtoRows
1993 type ProtoFormat struct {
1994 state protoimpl.MessageState
1995 sizeCache protoimpl.SizeCache
1996 unknownFields protoimpl.UnknownFields
1997 }
1998
1999 func (x *ProtoFormat) Reset() {
2000 *x = ProtoFormat{}
2001 mi := &file_google_bigtable_v2_data_proto_msgTypes[17]
2002 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2003 ms.StoreMessageInfo(mi)
2004 }
2005
2006 func (x *ProtoFormat) String() string {
2007 return protoimpl.X.MessageStringOf(x)
2008 }
2009
2010 func (*ProtoFormat) ProtoMessage() {}
2011
2012 func (x *ProtoFormat) ProtoReflect() protoreflect.Message {
2013 mi := &file_google_bigtable_v2_data_proto_msgTypes[17]
2014 if x != nil {
2015 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2016 if ms.LoadMessageInfo() == nil {
2017 ms.StoreMessageInfo(mi)
2018 }
2019 return ms
2020 }
2021 return mi.MessageOf(x)
2022 }
2023
2024 // Deprecated: Use ProtoFormat.ProtoReflect.Descriptor instead.
2025 func (*ProtoFormat) Descriptor() ([]byte, []int) {
2026 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{17}
2027 }
2028
2029 // Describes a column in a Bigtable Query Language result set.
2030 type ColumnMetadata struct {
2031 state protoimpl.MessageState
2032 sizeCache protoimpl.SizeCache
2033 unknownFields protoimpl.UnknownFields
2034
2035 // The name of the column.
2036 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
2037 // The type of the column.
2038 Type *Type `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
2039 }
2040
2041 func (x *ColumnMetadata) Reset() {
2042 *x = ColumnMetadata{}
2043 mi := &file_google_bigtable_v2_data_proto_msgTypes[18]
2044 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2045 ms.StoreMessageInfo(mi)
2046 }
2047
2048 func (x *ColumnMetadata) String() string {
2049 return protoimpl.X.MessageStringOf(x)
2050 }
2051
2052 func (*ColumnMetadata) ProtoMessage() {}
2053
2054 func (x *ColumnMetadata) ProtoReflect() protoreflect.Message {
2055 mi := &file_google_bigtable_v2_data_proto_msgTypes[18]
2056 if x != nil {
2057 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2058 if ms.LoadMessageInfo() == nil {
2059 ms.StoreMessageInfo(mi)
2060 }
2061 return ms
2062 }
2063 return mi.MessageOf(x)
2064 }
2065
2066 // Deprecated: Use ColumnMetadata.ProtoReflect.Descriptor instead.
2067 func (*ColumnMetadata) Descriptor() ([]byte, []int) {
2068 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{18}
2069 }
2070
2071 func (x *ColumnMetadata) GetName() string {
2072 if x != nil {
2073 return x.Name
2074 }
2075 return ""
2076 }
2077
2078 func (x *ColumnMetadata) GetType() *Type {
2079 if x != nil {
2080 return x.Type
2081 }
2082 return nil
2083 }
2084
2085 // ResultSet schema in proto format
2086 type ProtoSchema struct {
2087 state protoimpl.MessageState
2088 sizeCache protoimpl.SizeCache
2089 unknownFields protoimpl.UnknownFields
2090
2091 // The columns in the result set.
2092 Columns []*ColumnMetadata `protobuf:"bytes,1,rep,name=columns,proto3" json:"columns,omitempty"`
2093 }
2094
2095 func (x *ProtoSchema) Reset() {
2096 *x = ProtoSchema{}
2097 mi := &file_google_bigtable_v2_data_proto_msgTypes[19]
2098 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2099 ms.StoreMessageInfo(mi)
2100 }
2101
2102 func (x *ProtoSchema) String() string {
2103 return protoimpl.X.MessageStringOf(x)
2104 }
2105
2106 func (*ProtoSchema) ProtoMessage() {}
2107
2108 func (x *ProtoSchema) ProtoReflect() protoreflect.Message {
2109 mi := &file_google_bigtable_v2_data_proto_msgTypes[19]
2110 if x != nil {
2111 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2112 if ms.LoadMessageInfo() == nil {
2113 ms.StoreMessageInfo(mi)
2114 }
2115 return ms
2116 }
2117 return mi.MessageOf(x)
2118 }
2119
2120 // Deprecated: Use ProtoSchema.ProtoReflect.Descriptor instead.
2121 func (*ProtoSchema) Descriptor() ([]byte, []int) {
2122 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{19}
2123 }
2124
2125 func (x *ProtoSchema) GetColumns() []*ColumnMetadata {
2126 if x != nil {
2127 return x.Columns
2128 }
2129 return nil
2130 }
2131
2132 // Describes the structure of a Bigtable result set.
2133 type ResultSetMetadata struct {
2134 state protoimpl.MessageState
2135 sizeCache protoimpl.SizeCache
2136 unknownFields protoimpl.UnknownFields
2137
2138 // The schema of the ResultSet, contains ordered list of column names
2139 // with types
2140 //
2141 // Types that are assignable to Schema:
2142 //
2143 // *ResultSetMetadata_ProtoSchema
2144 Schema isResultSetMetadata_Schema `protobuf_oneof:"schema"`
2145 }
2146
2147 func (x *ResultSetMetadata) Reset() {
2148 *x = ResultSetMetadata{}
2149 mi := &file_google_bigtable_v2_data_proto_msgTypes[20]
2150 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2151 ms.StoreMessageInfo(mi)
2152 }
2153
2154 func (x *ResultSetMetadata) String() string {
2155 return protoimpl.X.MessageStringOf(x)
2156 }
2157
2158 func (*ResultSetMetadata) ProtoMessage() {}
2159
2160 func (x *ResultSetMetadata) ProtoReflect() protoreflect.Message {
2161 mi := &file_google_bigtable_v2_data_proto_msgTypes[20]
2162 if x != nil {
2163 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2164 if ms.LoadMessageInfo() == nil {
2165 ms.StoreMessageInfo(mi)
2166 }
2167 return ms
2168 }
2169 return mi.MessageOf(x)
2170 }
2171
2172 // Deprecated: Use ResultSetMetadata.ProtoReflect.Descriptor instead.
2173 func (*ResultSetMetadata) Descriptor() ([]byte, []int) {
2174 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{20}
2175 }
2176
2177 func (m *ResultSetMetadata) GetSchema() isResultSetMetadata_Schema {
2178 if m != nil {
2179 return m.Schema
2180 }
2181 return nil
2182 }
2183
2184 func (x *ResultSetMetadata) GetProtoSchema() *ProtoSchema {
2185 if x, ok := x.GetSchema().(*ResultSetMetadata_ProtoSchema); ok {
2186 return x.ProtoSchema
2187 }
2188 return nil
2189 }
2190
2191 type isResultSetMetadata_Schema interface {
2192 isResultSetMetadata_Schema()
2193 }
2194
2195 type ResultSetMetadata_ProtoSchema struct {
2196 // Schema in proto format
2197 ProtoSchema *ProtoSchema `protobuf:"bytes,1,opt,name=proto_schema,json=protoSchema,proto3,oneof"`
2198 }
2199
2200 func (*ResultSetMetadata_ProtoSchema) isResultSetMetadata_Schema() {}
2201
2202 // Rows represented in proto format.
2203 //
2204 // This should be constructed by concatenating the `batch_data` from each
2205 // of the relevant `ProtoRowsBatch` messages and parsing the result as a
2206 // `ProtoRows` message.
2207 type ProtoRows struct {
2208 state protoimpl.MessageState
2209 sizeCache protoimpl.SizeCache
2210 unknownFields protoimpl.UnknownFields
2211
2212 // A proto rows message consists of a list of values. Every N complete values
2213 // defines a row, where N is equal to the number of entries in the
2214 // `metadata.proto_schema.columns` value received in the first response.
2215 Values []*Value `protobuf:"bytes,2,rep,name=values,proto3" json:"values,omitempty"`
2216 }
2217
2218 func (x *ProtoRows) Reset() {
2219 *x = ProtoRows{}
2220 mi := &file_google_bigtable_v2_data_proto_msgTypes[21]
2221 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2222 ms.StoreMessageInfo(mi)
2223 }
2224
2225 func (x *ProtoRows) String() string {
2226 return protoimpl.X.MessageStringOf(x)
2227 }
2228
2229 func (*ProtoRows) ProtoMessage() {}
2230
2231 func (x *ProtoRows) ProtoReflect() protoreflect.Message {
2232 mi := &file_google_bigtable_v2_data_proto_msgTypes[21]
2233 if x != nil {
2234 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2235 if ms.LoadMessageInfo() == nil {
2236 ms.StoreMessageInfo(mi)
2237 }
2238 return ms
2239 }
2240 return mi.MessageOf(x)
2241 }
2242
2243 // Deprecated: Use ProtoRows.ProtoReflect.Descriptor instead.
2244 func (*ProtoRows) Descriptor() ([]byte, []int) {
2245 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{21}
2246 }
2247
2248 func (x *ProtoRows) GetValues() []*Value {
2249 if x != nil {
2250 return x.Values
2251 }
2252 return nil
2253 }
2254
2255 // A part of a serialized `ProtoRows` message.
2256 type ProtoRowsBatch struct {
2257 state protoimpl.MessageState
2258 sizeCache protoimpl.SizeCache
2259 unknownFields protoimpl.UnknownFields
2260
2261 // Part of a serialized `ProtoRows` message.
2262 // A complete, parseable ProtoRows message is constructed by
2263 // concatenating `batch_data` from multiple `ProtoRowsBatch` messages. The
2264 // `PartialResultSet` that contains the last part has `complete_batch` set to
2265 // `true`.
2266 BatchData []byte `protobuf:"bytes,1,opt,name=batch_data,json=batchData,proto3" json:"batch_data,omitempty"`
2267 }
2268
2269 func (x *ProtoRowsBatch) Reset() {
2270 *x = ProtoRowsBatch{}
2271 mi := &file_google_bigtable_v2_data_proto_msgTypes[22]
2272 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2273 ms.StoreMessageInfo(mi)
2274 }
2275
2276 func (x *ProtoRowsBatch) String() string {
2277 return protoimpl.X.MessageStringOf(x)
2278 }
2279
2280 func (*ProtoRowsBatch) ProtoMessage() {}
2281
2282 func (x *ProtoRowsBatch) ProtoReflect() protoreflect.Message {
2283 mi := &file_google_bigtable_v2_data_proto_msgTypes[22]
2284 if x != nil {
2285 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2286 if ms.LoadMessageInfo() == nil {
2287 ms.StoreMessageInfo(mi)
2288 }
2289 return ms
2290 }
2291 return mi.MessageOf(x)
2292 }
2293
2294 // Deprecated: Use ProtoRowsBatch.ProtoReflect.Descriptor instead.
2295 func (*ProtoRowsBatch) Descriptor() ([]byte, []int) {
2296 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{22}
2297 }
2298
2299 func (x *ProtoRowsBatch) GetBatchData() []byte {
2300 if x != nil {
2301 return x.BatchData
2302 }
2303 return nil
2304 }
2305
2306 // A partial result set from the streaming query API.
2307 // Cloud Bigtable clients buffer partial results received in this message until
2308 // a `resume_token` is received.
2309 //
2310 // The pseudocode below describes how to buffer and parse a stream of
2311 // `PartialResultSet` messages.
2312 //
2313 // Having:
2314 // - queue of row results waiting to be returned `queue`
2315 // - extensible buffer of bytes `buffer`
2316 // - a place to keep track of the most recent `resume_token`
2317 //
2318 // for each PartialResultSet `p` received {
2319 // if p.reset {
2320 // ensure `queue` is empty
2321 // ensure `buffer` is empty
2322 // }
2323 // if p.estimated_batch_size != 0 {
2324 // (optional) ensure `buffer` is sized to at least `p.estimated_batch_size`
2325 // }
2326 // if `p.proto_rows_batch` is set {
2327 // append `p.proto_rows_batch.bytes` to `buffer`
2328 // }
2329 // if p.batch_checksum is set and `buffer` is not empty {
2330 // validate the checksum matches the contents of `buffer`
2331 // (see comments on `batch_checksum`)
2332 // parse `buffer` as `ProtoRows` message, clearing `buffer`
2333 // add parsed rows to end of `queue`
2334 // }
2335 // if p.resume_token is set {
2336 // release results in `queue`
2337 // save `p.resume_token` in `resume_token`
2338 // }
2339 // }
2340 type PartialResultSet struct {
2341 state protoimpl.MessageState
2342 sizeCache protoimpl.SizeCache
2343 unknownFields protoimpl.UnknownFields
2344
2345 // Some rows of the result set in one of the supported formats.
2346 //
2347 // Multiple `PartialResultSet` messages may be sent to represent a complete
2348 // response. The client should buffer data constructed from the fields in
2349 // `partial_rows` until a non-empty `resume_token` is received. Each
2350 // sub-message documents the appropriate way to combine results.
2351 //
2352 // Types that are assignable to PartialRows:
2353 //
2354 // *PartialResultSet_ProtoRowsBatch
2355 PartialRows isPartialResultSet_PartialRows `protobuf_oneof:"partial_rows"`
2356 // CRC32C checksum of concatenated `partial_rows` data for the current batch.
2357 //
2358 // When present, the buffered data from `partial_rows` forms a complete
2359 // parseable message of the appropriate type.
2360 //
2361 // The client should mark the end of a parseable message and prepare to
2362 // receive a new one starting from the next `PartialResultSet` message.
2363 // Clients must verify the checksum of the serialized batch before yielding it
2364 // to the caller.
2365 //
2366 // This does NOT mean the values can be yielded to the callers since a
2367 // `resume_token` is required to safely do so.
2368 //
2369 // If `resume_token` is non-empty and any data has been received since the
2370 // last one, this field is guaranteed to be non-empty. In other words, clients
2371 // may assume that a batch will never cross a `resume_token` boundary.
2372 BatchChecksum *uint32 `protobuf:"varint,6,opt,name=batch_checksum,json=batchChecksum,proto3,oneof" json:"batch_checksum,omitempty"`
2373 // An opaque token sent by the server to allow query resumption and signal
2374 // that the buffered values constructed from received `partial_rows` can be
2375 // yielded to the caller. Clients can provide this token in a subsequent
2376 // request to resume the result stream from the current point.
2377 //
2378 // When `resume_token` is non-empty, the buffered values received from
2379 // `partial_rows` since the last non-empty `resume_token` can be yielded to
2380 // the callers, provided that the client keeps the value of `resume_token` and
2381 // uses it on subsequent retries.
2382 //
2383 // A `resume_token` may be sent without information in `partial_rows` to
2384 // checkpoint the progress of a sparse query. Any previous `partial_rows` data
2385 // should still be yielded in this case, and the new `resume_token` should be
2386 // saved for future retries as normal.
2387 //
2388 // A `resume_token` will only be sent on a boundary where there is either no
2389 // ongoing result batch, or `batch_checksum` is also populated.
2390 //
2391 // The server will also send a sentinel `resume_token` when last batch of
2392 // `partial_rows` is sent. If the client retries the ExecuteQueryRequest with
2393 // the sentinel `resume_token`, the server will emit it again without any
2394 // data in `partial_rows`, then return OK.
2395 ResumeToken []byte `protobuf:"bytes,5,opt,name=resume_token,json=resumeToken,proto3" json:"resume_token,omitempty"`
2396 // If `true`, any data buffered since the last non-empty `resume_token` must
2397 // be discarded before the other parts of this message, if any, are handled.
2398 Reset_ bool `protobuf:"varint,7,opt,name=reset,proto3" json:"reset,omitempty"`
2399 // Estimated size of the buffer required to hold the next batch of results.
2400 //
2401 // This value will be sent with the first `partial_rows` of a batch. That is,
2402 // on the first `partial_rows` received in a stream, on the first message
2403 // after a `batch_checksum` message, and any time `reset` is true.
2404 //
2405 // The client can use this estimate to allocate a buffer for the next batch of
2406 // results. This helps minimize the number of allocations required, though the
2407 // buffer size may still need to be increased if the estimate is too low.
2408 EstimatedBatchSize int32 `protobuf:"varint,4,opt,name=estimated_batch_size,json=estimatedBatchSize,proto3" json:"estimated_batch_size,omitempty"`
2409 }
2410
2411 func (x *PartialResultSet) Reset() {
2412 *x = PartialResultSet{}
2413 mi := &file_google_bigtable_v2_data_proto_msgTypes[23]
2414 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2415 ms.StoreMessageInfo(mi)
2416 }
2417
2418 func (x *PartialResultSet) String() string {
2419 return protoimpl.X.MessageStringOf(x)
2420 }
2421
2422 func (*PartialResultSet) ProtoMessage() {}
2423
2424 func (x *PartialResultSet) ProtoReflect() protoreflect.Message {
2425 mi := &file_google_bigtable_v2_data_proto_msgTypes[23]
2426 if x != nil {
2427 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2428 if ms.LoadMessageInfo() == nil {
2429 ms.StoreMessageInfo(mi)
2430 }
2431 return ms
2432 }
2433 return mi.MessageOf(x)
2434 }
2435
2436 // Deprecated: Use PartialResultSet.ProtoReflect.Descriptor instead.
2437 func (*PartialResultSet) Descriptor() ([]byte, []int) {
2438 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{23}
2439 }
2440
2441 func (m *PartialResultSet) GetPartialRows() isPartialResultSet_PartialRows {
2442 if m != nil {
2443 return m.PartialRows
2444 }
2445 return nil
2446 }
2447
2448 func (x *PartialResultSet) GetProtoRowsBatch() *ProtoRowsBatch {
2449 if x, ok := x.GetPartialRows().(*PartialResultSet_ProtoRowsBatch); ok {
2450 return x.ProtoRowsBatch
2451 }
2452 return nil
2453 }
2454
2455 func (x *PartialResultSet) GetBatchChecksum() uint32 {
2456 if x != nil && x.BatchChecksum != nil {
2457 return *x.BatchChecksum
2458 }
2459 return 0
2460 }
2461
2462 func (x *PartialResultSet) GetResumeToken() []byte {
2463 if x != nil {
2464 return x.ResumeToken
2465 }
2466 return nil
2467 }
2468
2469 func (x *PartialResultSet) GetReset_() bool {
2470 if x != nil {
2471 return x.Reset_
2472 }
2473 return false
2474 }
2475
2476 func (x *PartialResultSet) GetEstimatedBatchSize() int32 {
2477 if x != nil {
2478 return x.EstimatedBatchSize
2479 }
2480 return 0
2481 }
2482
2483 type isPartialResultSet_PartialRows interface {
2484 isPartialResultSet_PartialRows()
2485 }
2486
2487 type PartialResultSet_ProtoRowsBatch struct {
2488 // Partial rows in serialized ProtoRows format.
2489 ProtoRowsBatch *ProtoRowsBatch `protobuf:"bytes,3,opt,name=proto_rows_batch,json=protoRowsBatch,proto3,oneof"`
2490 }
2491
2492 func (*PartialResultSet_ProtoRowsBatch) isPartialResultSet_PartialRows() {}
2493
2494 // Parameters on mutations where clients want to ensure idempotency (i.e.
2495 // at-most-once semantics). This is currently only needed for certain aggregate
2496 // types.
2497 type Idempotency struct {
2498 state protoimpl.MessageState
2499 sizeCache protoimpl.SizeCache
2500 unknownFields protoimpl.UnknownFields
2501
2502 // Unique token used to identify replays of this mutation.
2503 // Must be at least 8 bytes long.
2504 Token []byte `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
2505 // Client-assigned timestamp when the mutation's first attempt was sent.
2506 // Used to reject mutations that arrive after idempotency protection may
2507 // have expired. May cause spurious rejections if clock skew is too high.
2508 //
2509 // Leave unset or zero to always accept the mutation, at the risk of
2510 // double counting if the protection for previous attempts has expired.
2511 StartTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
2512 }
2513
2514 func (x *Idempotency) Reset() {
2515 *x = Idempotency{}
2516 mi := &file_google_bigtable_v2_data_proto_msgTypes[24]
2517 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2518 ms.StoreMessageInfo(mi)
2519 }
2520
2521 func (x *Idempotency) String() string {
2522 return protoimpl.X.MessageStringOf(x)
2523 }
2524
2525 func (*Idempotency) ProtoMessage() {}
2526
2527 func (x *Idempotency) ProtoReflect() protoreflect.Message {
2528 mi := &file_google_bigtable_v2_data_proto_msgTypes[24]
2529 if x != nil {
2530 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2531 if ms.LoadMessageInfo() == nil {
2532 ms.StoreMessageInfo(mi)
2533 }
2534 return ms
2535 }
2536 return mi.MessageOf(x)
2537 }
2538
2539 // Deprecated: Use Idempotency.ProtoReflect.Descriptor instead.
2540 func (*Idempotency) Descriptor() ([]byte, []int) {
2541 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{24}
2542 }
2543
2544 func (x *Idempotency) GetToken() []byte {
2545 if x != nil {
2546 return x.Token
2547 }
2548 return nil
2549 }
2550
2551 func (x *Idempotency) GetStartTime() *timestamppb.Timestamp {
2552 if x != nil {
2553 return x.StartTime
2554 }
2555 return nil
2556 }
2557
2558 // A RowFilter which sends rows through several RowFilters in sequence.
2559 type RowFilter_Chain struct {
2560 state protoimpl.MessageState
2561 sizeCache protoimpl.SizeCache
2562 unknownFields protoimpl.UnknownFields
2563
2564 // The elements of "filters" are chained together to process the input row:
2565 // in row -> f(0) -> intermediate row -> f(1) -> ... -> f(N) -> out row
2566 // The full chain is executed atomically.
2567 Filters []*RowFilter `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"`
2568 }
2569
2570 func (x *RowFilter_Chain) Reset() {
2571 *x = RowFilter_Chain{}
2572 mi := &file_google_bigtable_v2_data_proto_msgTypes[25]
2573 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2574 ms.StoreMessageInfo(mi)
2575 }
2576
2577 func (x *RowFilter_Chain) String() string {
2578 return protoimpl.X.MessageStringOf(x)
2579 }
2580
2581 func (*RowFilter_Chain) ProtoMessage() {}
2582
2583 func (x *RowFilter_Chain) ProtoReflect() protoreflect.Message {
2584 mi := &file_google_bigtable_v2_data_proto_msgTypes[25]
2585 if x != nil {
2586 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2587 if ms.LoadMessageInfo() == nil {
2588 ms.StoreMessageInfo(mi)
2589 }
2590 return ms
2591 }
2592 return mi.MessageOf(x)
2593 }
2594
2595 // Deprecated: Use RowFilter_Chain.ProtoReflect.Descriptor instead.
2596 func (*RowFilter_Chain) Descriptor() ([]byte, []int) {
2597 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{11, 0}
2598 }
2599
2600 func (x *RowFilter_Chain) GetFilters() []*RowFilter {
2601 if x != nil {
2602 return x.Filters
2603 }
2604 return nil
2605 }
2606
2607 // A RowFilter which sends each row to each of several component
2608 // RowFilters and interleaves the results.
2609 type RowFilter_Interleave struct {
2610 state protoimpl.MessageState
2611 sizeCache protoimpl.SizeCache
2612 unknownFields protoimpl.UnknownFields
2613
2614 // The elements of "filters" all process a copy of the input row, and the
2615 // results are pooled, sorted, and combined into a single output row.
2616 // If multiple cells are produced with the same column and timestamp,
2617 // they will all appear in the output row in an unspecified mutual order.
2618 // Consider the following example, with three filters:
2619 //
2620 // input row
2621 // |
2622 // -----------------------------------------------------
2623 // | | |
2624 // f(0) f(1) f(2)
2625 // | | |
2626 // 1: foo,bar,10,x foo,bar,10,z far,bar,7,a
2627 // 2: foo,blah,11,z far,blah,5,x far,blah,5,x
2628 // | | |
2629 // -----------------------------------------------------
2630 // |
2631 // 1: foo,bar,10,z // could have switched with #2
2632 // 2: foo,bar,10,x // could have switched with #1
2633 // 3: foo,blah,11,z
2634 // 4: far,bar,7,a
2635 // 5: far,blah,5,x // identical to #6
2636 // 6: far,blah,5,x // identical to #5
2637 //
2638 // All interleaved filters are executed atomically.
2639 Filters []*RowFilter `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"`
2640 }
2641
2642 func (x *RowFilter_Interleave) Reset() {
2643 *x = RowFilter_Interleave{}
2644 mi := &file_google_bigtable_v2_data_proto_msgTypes[26]
2645 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2646 ms.StoreMessageInfo(mi)
2647 }
2648
2649 func (x *RowFilter_Interleave) String() string {
2650 return protoimpl.X.MessageStringOf(x)
2651 }
2652
2653 func (*RowFilter_Interleave) ProtoMessage() {}
2654
2655 func (x *RowFilter_Interleave) ProtoReflect() protoreflect.Message {
2656 mi := &file_google_bigtable_v2_data_proto_msgTypes[26]
2657 if x != nil {
2658 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2659 if ms.LoadMessageInfo() == nil {
2660 ms.StoreMessageInfo(mi)
2661 }
2662 return ms
2663 }
2664 return mi.MessageOf(x)
2665 }
2666
2667 // Deprecated: Use RowFilter_Interleave.ProtoReflect.Descriptor instead.
2668 func (*RowFilter_Interleave) Descriptor() ([]byte, []int) {
2669 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{11, 1}
2670 }
2671
2672 func (x *RowFilter_Interleave) GetFilters() []*RowFilter {
2673 if x != nil {
2674 return x.Filters
2675 }
2676 return nil
2677 }
2678
2679 // A RowFilter which evaluates one of two possible RowFilters, depending on
2680 // whether or not a predicate RowFilter outputs any cells from the input row.
2681 //
2682 // IMPORTANT NOTE: The predicate filter does not execute atomically with the
2683 // true and false filters, which may lead to inconsistent or unexpected
2684 // results. Additionally, Condition filters have poor performance, especially
2685 // when filters are set for the false condition.
2686 type RowFilter_Condition struct {
2687 state protoimpl.MessageState
2688 sizeCache protoimpl.SizeCache
2689 unknownFields protoimpl.UnknownFields
2690
2691 // If `predicate_filter` outputs any cells, then `true_filter` will be
2692 // evaluated on the input row. Otherwise, `false_filter` will be evaluated.
2693 PredicateFilter *RowFilter `protobuf:"bytes,1,opt,name=predicate_filter,json=predicateFilter,proto3" json:"predicate_filter,omitempty"`
2694 // The filter to apply to the input row if `predicate_filter` returns any
2695 // results. If not provided, no results will be returned in the true case.
2696 TrueFilter *RowFilter `protobuf:"bytes,2,opt,name=true_filter,json=trueFilter,proto3" json:"true_filter,omitempty"`
2697 // The filter to apply to the input row if `predicate_filter` does not
2698 // return any results. If not provided, no results will be returned in the
2699 // false case.
2700 FalseFilter *RowFilter `protobuf:"bytes,3,opt,name=false_filter,json=falseFilter,proto3" json:"false_filter,omitempty"`
2701 }
2702
2703 func (x *RowFilter_Condition) Reset() {
2704 *x = RowFilter_Condition{}
2705 mi := &file_google_bigtable_v2_data_proto_msgTypes[27]
2706 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2707 ms.StoreMessageInfo(mi)
2708 }
2709
2710 func (x *RowFilter_Condition) String() string {
2711 return protoimpl.X.MessageStringOf(x)
2712 }
2713
2714 func (*RowFilter_Condition) ProtoMessage() {}
2715
2716 func (x *RowFilter_Condition) ProtoReflect() protoreflect.Message {
2717 mi := &file_google_bigtable_v2_data_proto_msgTypes[27]
2718 if x != nil {
2719 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2720 if ms.LoadMessageInfo() == nil {
2721 ms.StoreMessageInfo(mi)
2722 }
2723 return ms
2724 }
2725 return mi.MessageOf(x)
2726 }
2727
2728 // Deprecated: Use RowFilter_Condition.ProtoReflect.Descriptor instead.
2729 func (*RowFilter_Condition) Descriptor() ([]byte, []int) {
2730 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{11, 2}
2731 }
2732
2733 func (x *RowFilter_Condition) GetPredicateFilter() *RowFilter {
2734 if x != nil {
2735 return x.PredicateFilter
2736 }
2737 return nil
2738 }
2739
2740 func (x *RowFilter_Condition) GetTrueFilter() *RowFilter {
2741 if x != nil {
2742 return x.TrueFilter
2743 }
2744 return nil
2745 }
2746
2747 func (x *RowFilter_Condition) GetFalseFilter() *RowFilter {
2748 if x != nil {
2749 return x.FalseFilter
2750 }
2751 return nil
2752 }
2753
2754 // A Mutation which sets the value of the specified cell.
2755 type Mutation_SetCell struct {
2756 state protoimpl.MessageState
2757 sizeCache protoimpl.SizeCache
2758 unknownFields protoimpl.UnknownFields
2759
2760 // The name of the family into which new data should be written.
2761 // Must match `[-_.a-zA-Z0-9]+`
2762 FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
2763 // The qualifier of the column into which new data should be written.
2764 // Can be any byte string, including the empty string.
2765 ColumnQualifier []byte `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier,proto3" json:"column_qualifier,omitempty"`
2766 // The timestamp of the cell into which new data should be written.
2767 // Use -1 for current Bigtable server time.
2768 // Otherwise, the client should set this value itself, noting that the
2769 // default value is a timestamp of zero if the field is left unspecified.
2770 // Values must match the granularity of the table (e.g. micros, millis).
2771 TimestampMicros int64 `protobuf:"varint,3,opt,name=timestamp_micros,json=timestampMicros,proto3" json:"timestamp_micros,omitempty"`
2772 // The value to be written into the specified cell.
2773 Value []byte `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"`
2774 }
2775
2776 func (x *Mutation_SetCell) Reset() {
2777 *x = Mutation_SetCell{}
2778 mi := &file_google_bigtable_v2_data_proto_msgTypes[28]
2779 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2780 ms.StoreMessageInfo(mi)
2781 }
2782
2783 func (x *Mutation_SetCell) String() string {
2784 return protoimpl.X.MessageStringOf(x)
2785 }
2786
2787 func (*Mutation_SetCell) ProtoMessage() {}
2788
2789 func (x *Mutation_SetCell) ProtoReflect() protoreflect.Message {
2790 mi := &file_google_bigtable_v2_data_proto_msgTypes[28]
2791 if x != nil {
2792 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2793 if ms.LoadMessageInfo() == nil {
2794 ms.StoreMessageInfo(mi)
2795 }
2796 return ms
2797 }
2798 return mi.MessageOf(x)
2799 }
2800
2801 // Deprecated: Use Mutation_SetCell.ProtoReflect.Descriptor instead.
2802 func (*Mutation_SetCell) Descriptor() ([]byte, []int) {
2803 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{12, 0}
2804 }
2805
2806 func (x *Mutation_SetCell) GetFamilyName() string {
2807 if x != nil {
2808 return x.FamilyName
2809 }
2810 return ""
2811 }
2812
2813 func (x *Mutation_SetCell) GetColumnQualifier() []byte {
2814 if x != nil {
2815 return x.ColumnQualifier
2816 }
2817 return nil
2818 }
2819
2820 func (x *Mutation_SetCell) GetTimestampMicros() int64 {
2821 if x != nil {
2822 return x.TimestampMicros
2823 }
2824 return 0
2825 }
2826
2827 func (x *Mutation_SetCell) GetValue() []byte {
2828 if x != nil {
2829 return x.Value
2830 }
2831 return nil
2832 }
2833
2834 // A Mutation which incrementally updates a cell in an `Aggregate` family.
2835 type Mutation_AddToCell struct {
2836 state protoimpl.MessageState
2837 sizeCache protoimpl.SizeCache
2838 unknownFields protoimpl.UnknownFields
2839
2840 // The name of the `Aggregate` family into which new data should be added.
2841 // This must be a family with a `value_type` of `Aggregate`.
2842 // Format: `[-_.a-zA-Z0-9]+`
2843 FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
2844 // The qualifier of the column into which new data should be added. This
2845 // must be a `raw_value`.
2846 ColumnQualifier *Value `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier,proto3" json:"column_qualifier,omitempty"`
2847 // The timestamp of the cell to which new data should be added. This must
2848 // be a `raw_timestamp_micros` that matches the table's `granularity`.
2849 Timestamp *Value `protobuf:"bytes,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
2850 // The input value to be accumulated into the specified cell. This must be
2851 // compatible with the family's `value_type.input_type`.
2852 Input *Value `protobuf:"bytes,4,opt,name=input,proto3" json:"input,omitempty"`
2853 }
2854
2855 func (x *Mutation_AddToCell) Reset() {
2856 *x = Mutation_AddToCell{}
2857 mi := &file_google_bigtable_v2_data_proto_msgTypes[29]
2858 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2859 ms.StoreMessageInfo(mi)
2860 }
2861
2862 func (x *Mutation_AddToCell) String() string {
2863 return protoimpl.X.MessageStringOf(x)
2864 }
2865
2866 func (*Mutation_AddToCell) ProtoMessage() {}
2867
2868 func (x *Mutation_AddToCell) ProtoReflect() protoreflect.Message {
2869 mi := &file_google_bigtable_v2_data_proto_msgTypes[29]
2870 if x != nil {
2871 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2872 if ms.LoadMessageInfo() == nil {
2873 ms.StoreMessageInfo(mi)
2874 }
2875 return ms
2876 }
2877 return mi.MessageOf(x)
2878 }
2879
2880 // Deprecated: Use Mutation_AddToCell.ProtoReflect.Descriptor instead.
2881 func (*Mutation_AddToCell) Descriptor() ([]byte, []int) {
2882 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{12, 1}
2883 }
2884
2885 func (x *Mutation_AddToCell) GetFamilyName() string {
2886 if x != nil {
2887 return x.FamilyName
2888 }
2889 return ""
2890 }
2891
2892 func (x *Mutation_AddToCell) GetColumnQualifier() *Value {
2893 if x != nil {
2894 return x.ColumnQualifier
2895 }
2896 return nil
2897 }
2898
2899 func (x *Mutation_AddToCell) GetTimestamp() *Value {
2900 if x != nil {
2901 return x.Timestamp
2902 }
2903 return nil
2904 }
2905
2906 func (x *Mutation_AddToCell) GetInput() *Value {
2907 if x != nil {
2908 return x.Input
2909 }
2910 return nil
2911 }
2912
2913 // A Mutation which merges accumulated state into a cell in an `Aggregate`
2914 // family.
2915 type Mutation_MergeToCell struct {
2916 state protoimpl.MessageState
2917 sizeCache protoimpl.SizeCache
2918 unknownFields protoimpl.UnknownFields
2919
2920 // The name of the `Aggregate` family into which new data should be added.
2921 // This must be a family with a `value_type` of `Aggregate`.
2922 // Format: `[-_.a-zA-Z0-9]+`
2923 FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
2924 // The qualifier of the column into which new data should be added. This
2925 // must be a `raw_value`.
2926 ColumnQualifier *Value `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier,proto3" json:"column_qualifier,omitempty"`
2927 // The timestamp of the cell to which new data should be added. This must
2928 // be a `raw_timestamp_micros` that matches the table's `granularity`.
2929 Timestamp *Value `protobuf:"bytes,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
2930 // The input value to be merged into the specified cell. This must be
2931 // compatible with the family's `value_type.state_type`. Merging `NULL` is
2932 // allowed, but has no effect.
2933 Input *Value `protobuf:"bytes,4,opt,name=input,proto3" json:"input,omitempty"`
2934 }
2935
2936 func (x *Mutation_MergeToCell) Reset() {
2937 *x = Mutation_MergeToCell{}
2938 mi := &file_google_bigtable_v2_data_proto_msgTypes[30]
2939 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2940 ms.StoreMessageInfo(mi)
2941 }
2942
2943 func (x *Mutation_MergeToCell) String() string {
2944 return protoimpl.X.MessageStringOf(x)
2945 }
2946
2947 func (*Mutation_MergeToCell) ProtoMessage() {}
2948
2949 func (x *Mutation_MergeToCell) ProtoReflect() protoreflect.Message {
2950 mi := &file_google_bigtable_v2_data_proto_msgTypes[30]
2951 if x != nil {
2952 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2953 if ms.LoadMessageInfo() == nil {
2954 ms.StoreMessageInfo(mi)
2955 }
2956 return ms
2957 }
2958 return mi.MessageOf(x)
2959 }
2960
2961 // Deprecated: Use Mutation_MergeToCell.ProtoReflect.Descriptor instead.
2962 func (*Mutation_MergeToCell) Descriptor() ([]byte, []int) {
2963 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{12, 2}
2964 }
2965
2966 func (x *Mutation_MergeToCell) GetFamilyName() string {
2967 if x != nil {
2968 return x.FamilyName
2969 }
2970 return ""
2971 }
2972
2973 func (x *Mutation_MergeToCell) GetColumnQualifier() *Value {
2974 if x != nil {
2975 return x.ColumnQualifier
2976 }
2977 return nil
2978 }
2979
2980 func (x *Mutation_MergeToCell) GetTimestamp() *Value {
2981 if x != nil {
2982 return x.Timestamp
2983 }
2984 return nil
2985 }
2986
2987 func (x *Mutation_MergeToCell) GetInput() *Value {
2988 if x != nil {
2989 return x.Input
2990 }
2991 return nil
2992 }
2993
2994 // A Mutation which deletes cells from the specified column, optionally
2995 // restricting the deletions to a given timestamp range.
2996 type Mutation_DeleteFromColumn struct {
2997 state protoimpl.MessageState
2998 sizeCache protoimpl.SizeCache
2999 unknownFields protoimpl.UnknownFields
3000
3001 // The name of the family from which cells should be deleted.
3002 // Must match `[-_.a-zA-Z0-9]+`
3003 FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
3004 // The qualifier of the column from which cells should be deleted.
3005 // Can be any byte string, including the empty string.
3006 ColumnQualifier []byte `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier,proto3" json:"column_qualifier,omitempty"`
3007 // The range of timestamps within which cells should be deleted.
3008 TimeRange *TimestampRange `protobuf:"bytes,3,opt,name=time_range,json=timeRange,proto3" json:"time_range,omitempty"`
3009 }
3010
3011 func (x *Mutation_DeleteFromColumn) Reset() {
3012 *x = Mutation_DeleteFromColumn{}
3013 mi := &file_google_bigtable_v2_data_proto_msgTypes[31]
3014 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
3015 ms.StoreMessageInfo(mi)
3016 }
3017
3018 func (x *Mutation_DeleteFromColumn) String() string {
3019 return protoimpl.X.MessageStringOf(x)
3020 }
3021
3022 func (*Mutation_DeleteFromColumn) ProtoMessage() {}
3023
3024 func (x *Mutation_DeleteFromColumn) ProtoReflect() protoreflect.Message {
3025 mi := &file_google_bigtable_v2_data_proto_msgTypes[31]
3026 if x != nil {
3027 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
3028 if ms.LoadMessageInfo() == nil {
3029 ms.StoreMessageInfo(mi)
3030 }
3031 return ms
3032 }
3033 return mi.MessageOf(x)
3034 }
3035
3036 // Deprecated: Use Mutation_DeleteFromColumn.ProtoReflect.Descriptor instead.
3037 func (*Mutation_DeleteFromColumn) Descriptor() ([]byte, []int) {
3038 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{12, 3}
3039 }
3040
3041 func (x *Mutation_DeleteFromColumn) GetFamilyName() string {
3042 if x != nil {
3043 return x.FamilyName
3044 }
3045 return ""
3046 }
3047
3048 func (x *Mutation_DeleteFromColumn) GetColumnQualifier() []byte {
3049 if x != nil {
3050 return x.ColumnQualifier
3051 }
3052 return nil
3053 }
3054
3055 func (x *Mutation_DeleteFromColumn) GetTimeRange() *TimestampRange {
3056 if x != nil {
3057 return x.TimeRange
3058 }
3059 return nil
3060 }
3061
3062 // A Mutation which deletes all cells from the specified column family.
3063 type Mutation_DeleteFromFamily struct {
3064 state protoimpl.MessageState
3065 sizeCache protoimpl.SizeCache
3066 unknownFields protoimpl.UnknownFields
3067
3068 // The name of the family from which cells should be deleted.
3069 // Must match `[-_.a-zA-Z0-9]+`
3070 FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName,proto3" json:"family_name,omitempty"`
3071 }
3072
3073 func (x *Mutation_DeleteFromFamily) Reset() {
3074 *x = Mutation_DeleteFromFamily{}
3075 mi := &file_google_bigtable_v2_data_proto_msgTypes[32]
3076 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
3077 ms.StoreMessageInfo(mi)
3078 }
3079
3080 func (x *Mutation_DeleteFromFamily) String() string {
3081 return protoimpl.X.MessageStringOf(x)
3082 }
3083
3084 func (*Mutation_DeleteFromFamily) ProtoMessage() {}
3085
3086 func (x *Mutation_DeleteFromFamily) ProtoReflect() protoreflect.Message {
3087 mi := &file_google_bigtable_v2_data_proto_msgTypes[32]
3088 if x != nil {
3089 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
3090 if ms.LoadMessageInfo() == nil {
3091 ms.StoreMessageInfo(mi)
3092 }
3093 return ms
3094 }
3095 return mi.MessageOf(x)
3096 }
3097
3098 // Deprecated: Use Mutation_DeleteFromFamily.ProtoReflect.Descriptor instead.
3099 func (*Mutation_DeleteFromFamily) Descriptor() ([]byte, []int) {
3100 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{12, 4}
3101 }
3102
3103 func (x *Mutation_DeleteFromFamily) GetFamilyName() string {
3104 if x != nil {
3105 return x.FamilyName
3106 }
3107 return ""
3108 }
3109
3110 // A Mutation which deletes all cells from the containing row.
3111 type Mutation_DeleteFromRow struct {
3112 state protoimpl.MessageState
3113 sizeCache protoimpl.SizeCache
3114 unknownFields protoimpl.UnknownFields
3115 }
3116
3117 func (x *Mutation_DeleteFromRow) Reset() {
3118 *x = Mutation_DeleteFromRow{}
3119 mi := &file_google_bigtable_v2_data_proto_msgTypes[33]
3120 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
3121 ms.StoreMessageInfo(mi)
3122 }
3123
3124 func (x *Mutation_DeleteFromRow) String() string {
3125 return protoimpl.X.MessageStringOf(x)
3126 }
3127
3128 func (*Mutation_DeleteFromRow) ProtoMessage() {}
3129
3130 func (x *Mutation_DeleteFromRow) ProtoReflect() protoreflect.Message {
3131 mi := &file_google_bigtable_v2_data_proto_msgTypes[33]
3132 if x != nil {
3133 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
3134 if ms.LoadMessageInfo() == nil {
3135 ms.StoreMessageInfo(mi)
3136 }
3137 return ms
3138 }
3139 return mi.MessageOf(x)
3140 }
3141
3142 // Deprecated: Use Mutation_DeleteFromRow.ProtoReflect.Descriptor instead.
3143 func (*Mutation_DeleteFromRow) Descriptor() ([]byte, []int) {
3144 return file_google_bigtable_v2_data_proto_rawDescGZIP(), []int{12, 5}
3145 }
3146
3147 var File_google_bigtable_v2_data_proto protoreflect.FileDescriptor
3148
3149 var file_google_bigtable_v2_data_proto_rawDesc = []byte{
3150 0x0a, 0x1d, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c,
3151 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12,
3152 0x12, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65,
3153 0x2e, 0x76, 0x32, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f,
3154 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x62, 0x65, 0x68, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x2e, 0x70,
3155 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x62, 0x69, 0x67,
3156 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2f, 0x76, 0x32, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x70,
3157 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f,
3158 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e,
3159 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x16, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x74, 0x79,
3160 0x70, 0x65, 0x2f, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x4f, 0x0a,
3161 0x03, 0x52, 0x6f, 0x77, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28,
3162 0x0c, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x36, 0x0a, 0x08, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x69,
3163 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
3164 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x46, 0x61,
3165 0x6d, 0x69, 0x6c, 0x79, 0x52, 0x08, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x69, 0x65, 0x73, 0x22, 0x52,
3166 0x0a, 0x06, 0x46, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65,
3167 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x34, 0x0a, 0x07,
3168 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e,
3169 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e,
3170 0x76, 0x32, 0x2e, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x07, 0x63, 0x6f, 0x6c, 0x75, 0x6d,
3171 0x6e, 0x73, 0x22, 0x56, 0x0a, 0x06, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12, 0x1c, 0x0a, 0x09,
3172 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52,
3173 0x09, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x2e, 0x0a, 0x05, 0x63, 0x65,
3174 0x6c, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
3175 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x43,
3176 0x65, 0x6c, 0x6c, 0x52, 0x05, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x22, 0x5f, 0x0a, 0x04, 0x43, 0x65,
3177 0x6c, 0x6c, 0x12, 0x29, 0x0a, 0x10, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f,
3178 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x74, 0x69,
3179 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x12, 0x14, 0x0a,
3180 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61,
3181 0x6c, 0x75, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x03, 0x20,
3182 0x03, 0x28, 0x09, 0x52, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x22, 0xf9, 0x03, 0x0a, 0x05,
3183 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x2c, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x07, 0x20,
3184 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67,
3185 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74,
3186 0x79, 0x70, 0x65, 0x12, 0x1d, 0x0a, 0x09, 0x72, 0x61, 0x77, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65,
3187 0x18, 0x08, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x08, 0x72, 0x61, 0x77, 0x56, 0x61, 0x6c,
3188 0x75, 0x65, 0x12, 0x32, 0x0a, 0x14, 0x72, 0x61, 0x77, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74,
3189 0x61, 0x6d, 0x70, 0x5f, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03,
3190 0x48, 0x00, 0x52, 0x12, 0x72, 0x61, 0x77, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
3191 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x12, 0x21, 0x0a, 0x0b, 0x62, 0x79, 0x74, 0x65, 0x73, 0x5f,
3192 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0a, 0x62,
3193 0x79, 0x74, 0x65, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x23, 0x0a, 0x0c, 0x73, 0x74, 0x72,
3194 0x69, 0x6e, 0x67, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x48,
3195 0x00, 0x52, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1d,
3196 0x0a, 0x09, 0x69, 0x6e, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28,
3197 0x03, 0x48, 0x00, 0x52, 0x08, 0x69, 0x6e, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1f, 0x0a,
3198 0x0a, 0x62, 0x6f, 0x6f, 0x6c, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28,
3199 0x08, 0x48, 0x00, 0x52, 0x09, 0x62, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x21,
3200 0x0a, 0x0b, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x0b, 0x20,
3201 0x01, 0x28, 0x01, 0x48, 0x00, 0x52, 0x0a, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x56, 0x61, 0x6c, 0x75,
3202 0x65, 0x12, 0x45, 0x0a, 0x0f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x76,
3203 0x61, 0x6c, 0x75, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f,
3204 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d,
3205 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x48, 0x00, 0x52, 0x0e, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74,
3206 0x61, 0x6d, 0x70, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x32, 0x0a, 0x0a, 0x64, 0x61, 0x74, 0x65,
3207 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x67,
3208 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x48,
3209 0x00, 0x52, 0x09, 0x64, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x41, 0x0a, 0x0b,
3210 0x61, 0x72, 0x72, 0x61, 0x79, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28,
3211 0x0b, 0x32, 0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61,
3212 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x41, 0x72, 0x72, 0x61, 0x79, 0x56, 0x61, 0x6c, 0x75,
3213 0x65, 0x48, 0x00, 0x52, 0x0a, 0x61, 0x72, 0x72, 0x61, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42,
3214 0x06, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x22, 0x3f, 0x0a, 0x0a, 0x41, 0x72, 0x72, 0x61, 0x79,
3215 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x31, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18,
3216 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62,
3217 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65,
3218 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x22, 0xc2, 0x01, 0x0a, 0x08, 0x52, 0x6f, 0x77,
3219 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x2a, 0x0a, 0x10, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x6b,
3220 0x65, 0x79, 0x5f, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x48,
3221 0x00, 0x52, 0x0e, 0x73, 0x74, 0x61, 0x72, 0x74, 0x4b, 0x65, 0x79, 0x43, 0x6c, 0x6f, 0x73, 0x65,
3222 0x64, 0x12, 0x26, 0x0a, 0x0e, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x6f,
3223 0x70, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0c, 0x73, 0x74, 0x61,
3224 0x72, 0x74, 0x4b, 0x65, 0x79, 0x4f, 0x70, 0x65, 0x6e, 0x12, 0x22, 0x0a, 0x0c, 0x65, 0x6e, 0x64,
3225 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x48,
3226 0x01, 0x52, 0x0a, 0x65, 0x6e, 0x64, 0x4b, 0x65, 0x79, 0x4f, 0x70, 0x65, 0x6e, 0x12, 0x26, 0x0a,
3227 0x0e, 0x65, 0x6e, 0x64, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x18,
3228 0x04, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x01, 0x52, 0x0c, 0x65, 0x6e, 0x64, 0x4b, 0x65, 0x79, 0x43,
3229 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x42, 0x0b, 0x0a, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x6b,
3230 0x65, 0x79, 0x42, 0x09, 0x0a, 0x07, 0x65, 0x6e, 0x64, 0x5f, 0x6b, 0x65, 0x79, 0x22, 0x60, 0x0a,
3231 0x06, 0x52, 0x6f, 0x77, 0x53, 0x65, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x6f, 0x77, 0x5f, 0x6b,
3232 0x65, 0x79, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x07, 0x72, 0x6f, 0x77, 0x4b, 0x65,
3233 0x79, 0x73, 0x12, 0x3b, 0x0a, 0x0a, 0x72, 0x6f, 0x77, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73,
3234 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
3235 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x52, 0x6f, 0x77, 0x52,
3236 0x61, 0x6e, 0x67, 0x65, 0x52, 0x09, 0x72, 0x6f, 0x77, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x22,
3237 0xa2, 0x02, 0x0a, 0x0b, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12,
3238 0x1f, 0x0a, 0x0b, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01,
3239 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x4e, 0x61, 0x6d, 0x65,
3240 0x12, 0x36, 0x0a, 0x16, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66,
3241 0x69, 0x65, 0x72, 0x5f, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c,
3242 0x48, 0x00, 0x52, 0x14, 0x73, 0x74, 0x61, 0x72, 0x74, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69,
3243 0x65, 0x72, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x12, 0x32, 0x0a, 0x14, 0x73, 0x74, 0x61, 0x72,
3244 0x74, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x5f, 0x6f, 0x70, 0x65, 0x6e,
3245 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x12, 0x73, 0x74, 0x61, 0x72, 0x74, 0x51,
3246 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x4f, 0x70, 0x65, 0x6e, 0x12, 0x32, 0x0a, 0x14,
3247 0x65, 0x6e, 0x64, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x5f, 0x63, 0x6c,
3248 0x6f, 0x73, 0x65, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x01, 0x52, 0x12, 0x65, 0x6e,
3249 0x64, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64,
3250 0x12, 0x2e, 0x0a, 0x12, 0x65, 0x6e, 0x64, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65,
3251 0x72, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x01, 0x52, 0x10,
3252 0x65, 0x6e, 0x64, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x4f, 0x70, 0x65, 0x6e,
3253 0x42, 0x11, 0x0a, 0x0f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66,
3254 0x69, 0x65, 0x72, 0x42, 0x0f, 0x0a, 0x0d, 0x65, 0x6e, 0x64, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69,
3255 0x66, 0x69, 0x65, 0x72, 0x22, 0x78, 0x0a, 0x0e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d,
3256 0x70, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x34, 0x0a, 0x16, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f,
3257 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73,
3258 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x14, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d,
3259 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x12, 0x30, 0x0a, 0x14,
3260 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x6d, 0x69,
3261 0x63, 0x72, 0x6f, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x65, 0x6e, 0x64, 0x54,
3262 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x22, 0xd8,
3263 0x01, 0x0a, 0x0a, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x2e, 0x0a,
3264 0x12, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x63, 0x6c, 0x6f,
3265 0x73, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x10, 0x73, 0x74, 0x61,
3266 0x72, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x12, 0x2a, 0x0a,
3267 0x10, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x6f, 0x70, 0x65,
3268 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0e, 0x73, 0x74, 0x61, 0x72, 0x74,
3269 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x65, 0x6e, 0x12, 0x2a, 0x0a, 0x10, 0x65, 0x6e, 0x64,
3270 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x18, 0x03, 0x20,
3271 0x01, 0x28, 0x0c, 0x48, 0x01, 0x52, 0x0e, 0x65, 0x6e, 0x64, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x43,
3272 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x12, 0x26, 0x0a, 0x0e, 0x65, 0x6e, 0x64, 0x5f, 0x76, 0x61, 0x6c,
3273 0x75, 0x65, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x01, 0x52,
3274 0x0c, 0x65, 0x6e, 0x64, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x65, 0x6e, 0x42, 0x0d, 0x0a,
3275 0x0b, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x0b, 0x0a, 0x09,
3276 0x65, 0x6e, 0x64, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0xfc, 0x0b, 0x0a, 0x09, 0x52, 0x6f,
3277 0x77, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x3b, 0x0a, 0x05, 0x63, 0x68, 0x61, 0x69, 0x6e,
3278 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
3279 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x52, 0x6f, 0x77, 0x46,
3280 0x69, 0x6c, 0x74, 0x65, 0x72, 0x2e, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x48, 0x00, 0x52, 0x05, 0x63,
3281 0x68, 0x61, 0x69, 0x6e, 0x12, 0x4a, 0x0a, 0x0a, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6c, 0x65, 0x61,
3282 0x76, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
3283 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x52, 0x6f,
3284 0x77, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6c, 0x65, 0x61,
3285 0x76, 0x65, 0x48, 0x00, 0x52, 0x0a, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6c, 0x65, 0x61, 0x76, 0x65,
3286 0x12, 0x47, 0x0a, 0x09, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20,
3287 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67,
3288 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x52, 0x6f, 0x77, 0x46, 0x69, 0x6c, 0x74,
3289 0x65, 0x72, 0x2e, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x09,
3290 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x04, 0x73, 0x69, 0x6e,
3291 0x6b, 0x18, 0x10, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x04, 0x73, 0x69, 0x6e, 0x6b, 0x12,
3292 0x28, 0x0a, 0x0f, 0x70, 0x61, 0x73, 0x73, 0x5f, 0x61, 0x6c, 0x6c, 0x5f, 0x66, 0x69, 0x6c, 0x74,
3293 0x65, 0x72, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x0d, 0x70, 0x61, 0x73, 0x73,
3294 0x41, 0x6c, 0x6c, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x2a, 0x0a, 0x10, 0x62, 0x6c, 0x6f,
3295 0x63, 0x6b, 0x5f, 0x61, 0x6c, 0x6c, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x12, 0x20,
3296 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x0e, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x41, 0x6c, 0x6c, 0x46,
3297 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x31, 0x0a, 0x14, 0x72, 0x6f, 0x77, 0x5f, 0x6b, 0x65, 0x79,
3298 0x5f, 0x72, 0x65, 0x67, 0x65, 0x78, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x04, 0x20,
3299 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x11, 0x72, 0x6f, 0x77, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x67,
3300 0x65, 0x78, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x2c, 0x0a, 0x11, 0x72, 0x6f, 0x77, 0x5f,
3301 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x0e, 0x20,
3302 0x01, 0x28, 0x01, 0x48, 0x00, 0x52, 0x0f, 0x72, 0x6f, 0x77, 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65,
3303 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x39, 0x0a, 0x18, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79,
3304 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x72, 0x65, 0x67, 0x65, 0x78, 0x5f, 0x66, 0x69, 0x6c, 0x74,
3305 0x65, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x15, 0x66, 0x61, 0x6d, 0x69,
3306 0x6c, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x67, 0x65, 0x78, 0x46, 0x69, 0x6c, 0x74, 0x65,
3307 0x72, 0x12, 0x43, 0x0a, 0x1d, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x71, 0x75, 0x61, 0x6c,
3308 0x69, 0x66, 0x69, 0x65, 0x72, 0x5f, 0x72, 0x65, 0x67, 0x65, 0x78, 0x5f, 0x66, 0x69, 0x6c, 0x74,
3309 0x65, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x1a, 0x63, 0x6f, 0x6c, 0x75,
3310 0x6d, 0x6e, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x65, 0x67, 0x65, 0x78,
3311 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x51, 0x0a, 0x13, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e,
3312 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x07, 0x20,
3313 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67,
3314 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52,
3315 0x61, 0x6e, 0x67, 0x65, 0x48, 0x00, 0x52, 0x11, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x52, 0x61,
3316 0x6e, 0x67, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x5a, 0x0a, 0x16, 0x74, 0x69, 0x6d,
3317 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x66, 0x69, 0x6c,
3318 0x74, 0x65, 0x72, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
3319 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x54,
3320 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x48, 0x00, 0x52,
3321 0x14, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x46,
3322 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x2e, 0x0a, 0x12, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x72,
3323 0x65, 0x67, 0x65, 0x78, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x09, 0x20, 0x01, 0x28,
3324 0x0c, 0x48, 0x00, 0x52, 0x10, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x67, 0x65, 0x78, 0x46,
3325 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x4e, 0x0a, 0x12, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x72,
3326 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x0f, 0x20, 0x01, 0x28,
3327 0x0b, 0x32, 0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61,
3328 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x61, 0x6e, 0x67,
3329 0x65, 0x48, 0x00, 0x52, 0x10, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x46,
3330 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x3e, 0x0a, 0x1b, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x5f, 0x70,
3331 0x65, 0x72, 0x5f, 0x72, 0x6f, 0x77, 0x5f, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x5f, 0x66, 0x69,
3332 0x6c, 0x74, 0x65, 0x72, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x17, 0x63, 0x65,
3333 0x6c, 0x6c, 0x73, 0x50, 0x65, 0x72, 0x52, 0x6f, 0x77, 0x4f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x46,
3334 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x3c, 0x0a, 0x1a, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x5f, 0x70,
3335 0x65, 0x72, 0x5f, 0x72, 0x6f, 0x77, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x66, 0x69, 0x6c,
3336 0x74, 0x65, 0x72, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x16, 0x63, 0x65, 0x6c,
3337 0x6c, 0x73, 0x50, 0x65, 0x72, 0x52, 0x6f, 0x77, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x46, 0x69, 0x6c,
3338 0x74, 0x65, 0x72, 0x12, 0x42, 0x0a, 0x1d, 0x63, 0x65, 0x6c, 0x6c, 0x73, 0x5f, 0x70, 0x65, 0x72,
3339 0x5f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x66, 0x69,
3340 0x6c, 0x74, 0x65, 0x72, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x19, 0x63, 0x65,
3341 0x6c, 0x6c, 0x73, 0x50, 0x65, 0x72, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4c, 0x69, 0x6d, 0x69,
3342 0x74, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x38, 0x0a, 0x17, 0x73, 0x74, 0x72, 0x69, 0x70,
3343 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d,
3344 0x65, 0x72, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x15, 0x73, 0x74, 0x72, 0x69,
3345 0x70, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x65,
3346 0x72, 0x12, 0x38, 0x0a, 0x17, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x5f, 0x6c, 0x61, 0x62, 0x65, 0x6c,
3347 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x72, 0x18, 0x13, 0x20, 0x01,
3348 0x28, 0x09, 0x48, 0x00, 0x52, 0x15, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x4c, 0x61, 0x62, 0x65, 0x6c,
3349 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x72, 0x1a, 0x40, 0x0a, 0x05, 0x43,
3350 0x68, 0x61, 0x69, 0x6e, 0x12, 0x37, 0x0a, 0x07, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x18,
3351 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62,
3352 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x52, 0x6f, 0x77, 0x46, 0x69,
3353 0x6c, 0x74, 0x65, 0x72, 0x52, 0x07, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x1a, 0x45, 0x0a,
3354 0x0a, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6c, 0x65, 0x61, 0x76, 0x65, 0x12, 0x37, 0x0a, 0x07, 0x66,
3355 0x69, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67,
3356 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76,
3357 0x32, 0x2e, 0x52, 0x6f, 0x77, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x52, 0x07, 0x66, 0x69, 0x6c,
3358 0x74, 0x65, 0x72, 0x73, 0x1a, 0xd7, 0x01, 0x0a, 0x09, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69,
3359 0x6f, 0x6e, 0x12, 0x48, 0x0a, 0x10, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x5f,
3360 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67,
3361 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76,
3362 0x32, 0x2e, 0x52, 0x6f, 0x77, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x52, 0x0f, 0x70, 0x72, 0x65,
3363 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x3e, 0x0a, 0x0b,
3364 0x74, 0x72, 0x75, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28,
3365 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61,
3366 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x52, 0x6f, 0x77, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72,
3367 0x52, 0x0a, 0x74, 0x72, 0x75, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x40, 0x0a, 0x0c,
3368 0x66, 0x61, 0x6c, 0x73, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01,
3369 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74,
3370 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x52, 0x6f, 0x77, 0x46, 0x69, 0x6c, 0x74, 0x65,
3371 0x72, 0x52, 0x0b, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x42, 0x08,
3372 0x0a, 0x06, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x22, 0xca, 0x0a, 0x0a, 0x08, 0x4d, 0x75, 0x74,
3373 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x41, 0x0a, 0x08, 0x73, 0x65, 0x74, 0x5f, 0x63, 0x65, 0x6c,
3374 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
3375 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x4d, 0x75, 0x74,
3376 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x53, 0x65, 0x74, 0x43, 0x65, 0x6c, 0x6c, 0x48, 0x00, 0x52,
3377 0x07, 0x73, 0x65, 0x74, 0x43, 0x65, 0x6c, 0x6c, 0x12, 0x48, 0x0a, 0x0b, 0x61, 0x64, 0x64, 0x5f,
3378 0x74, 0x6f, 0x5f, 0x63, 0x65, 0x6c, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e,
3379 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e,
3380 0x76, 0x32, 0x2e, 0x4d, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x41, 0x64, 0x64, 0x54,
3381 0x6f, 0x43, 0x65, 0x6c, 0x6c, 0x48, 0x00, 0x52, 0x09, 0x61, 0x64, 0x64, 0x54, 0x6f, 0x43, 0x65,
3382 0x6c, 0x6c, 0x12, 0x4e, 0x0a, 0x0d, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x5f, 0x74, 0x6f, 0x5f, 0x63,
3383 0x65, 0x6c, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
3384 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x4d,
3385 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x4d, 0x65, 0x72, 0x67, 0x65, 0x54, 0x6f, 0x43,
3386 0x65, 0x6c, 0x6c, 0x48, 0x00, 0x52, 0x0b, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x54, 0x6f, 0x43, 0x65,
3387 0x6c, 0x6c, 0x12, 0x5d, 0x0a, 0x12, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x5f, 0x66, 0x72, 0x6f,
3388 0x6d, 0x5f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d,
3389 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65,
3390 0x2e, 0x76, 0x32, 0x2e, 0x4d, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x65, 0x6c,
3391 0x65, 0x74, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x48, 0x00, 0x52,
3392 0x10, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x6f, 0x6c, 0x75, 0x6d,
3393 0x6e, 0x12, 0x5d, 0x0a, 0x12, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x5f, 0x66, 0x72, 0x6f, 0x6d,
3394 0x5f, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e,
3395 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e,
3396 0x76, 0x32, 0x2e, 0x4d, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x65, 0x6c, 0x65,
3397 0x74, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x46, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x48, 0x00, 0x52, 0x10,
3398 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x46, 0x61, 0x6d, 0x69, 0x6c, 0x79,
3399 0x12, 0x54, 0x0a, 0x0f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f,
3400 0x72, 0x6f, 0x77, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
3401 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x4d,
3402 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x72,
3403 0x6f, 0x6d, 0x52, 0x6f, 0x77, 0x48, 0x00, 0x52, 0x0d, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46,
3404 0x72, 0x6f, 0x6d, 0x52, 0x6f, 0x77, 0x1a, 0x96, 0x01, 0x0a, 0x07, 0x53, 0x65, 0x74, 0x43, 0x65,
3405 0x6c, 0x6c, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x5f, 0x6e, 0x61, 0x6d,
3406 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x4e,
3407 0x61, 0x6d, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x71, 0x75,
3408 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x63,
3409 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x29,
3410 0x0a, 0x10, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x6d, 0x69, 0x63, 0x72,
3411 0x6f, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74,
3412 0x61, 0x6d, 0x70, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c,
3413 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x1a,
3414 0xdc, 0x01, 0x0a, 0x09, 0x41, 0x64, 0x64, 0x54, 0x6f, 0x43, 0x65, 0x6c, 0x6c, 0x12, 0x1f, 0x0a,
3415 0x0b, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01,
3416 0x28, 0x09, 0x52, 0x0a, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x44,
3417 0x0a, 0x10, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69,
3418 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
3419 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x56, 0x61,
3420 0x6c, 0x75, 0x65, 0x52, 0x0f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x51, 0x75, 0x61, 0x6c, 0x69,
3421 0x66, 0x69, 0x65, 0x72, 0x12, 0x37, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d,
3422 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
3423 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x56, 0x61, 0x6c,
3424 0x75, 0x65, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x2f, 0x0a,
3425 0x05, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67,
3426 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76,
3427 0x32, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x05, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x1a, 0xde,
3428 0x01, 0x0a, 0x0b, 0x4d, 0x65, 0x72, 0x67, 0x65, 0x54, 0x6f, 0x43, 0x65, 0x6c, 0x6c, 0x12, 0x1f,
3429 0x0a, 0x0b, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20,
3430 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12,
3431 0x44, 0x0a, 0x10, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66,
3432 0x69, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
3433 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x56,
3434 0x61, 0x6c, 0x75, 0x65, 0x52, 0x0f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x51, 0x75, 0x61, 0x6c,
3435 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x37, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61,
3436 0x6d, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
3437 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x56, 0x61,
3438 0x6c, 0x75, 0x65, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x2f,
3439 0x0a, 0x05, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e,
3440 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e,
3441 0x76, 0x32, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x05, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x1a,
3442 0xa1, 0x01, 0x0a, 0x10, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x6f,
3443 0x6c, 0x75, 0x6d, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x5f, 0x6e,
3444 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x61, 0x6d, 0x69, 0x6c,
3445 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f,
3446 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52,
3447 0x0f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x51, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72,
3448 0x12, 0x41, 0x0a, 0x0a, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x03,
3449 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69,
3450 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74,
3451 0x61, 0x6d, 0x70, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x52, 0x61,
3452 0x6e, 0x67, 0x65, 0x1a, 0x33, 0x0a, 0x10, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x72, 0x6f,
3453 0x6d, 0x46, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x61, 0x6d, 0x69, 0x6c,
3454 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x61,
3455 0x6d, 0x69, 0x6c, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x1a, 0x0f, 0x0a, 0x0d, 0x44, 0x65, 0x6c, 0x65,
3456 0x74, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x52, 0x6f, 0x77, 0x42, 0x0a, 0x0a, 0x08, 0x6d, 0x75, 0x74,
3457 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xbb, 0x01, 0x0a, 0x13, 0x52, 0x65, 0x61, 0x64, 0x4d, 0x6f,
3458 0x64, 0x69, 0x66, 0x79, 0x57, 0x72, 0x69, 0x74, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x12, 0x1f, 0x0a,
3459 0x0b, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01,
3460 0x28, 0x09, 0x52, 0x0a, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x29,
3461 0x0a, 0x10, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69,
3462 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e,
3463 0x51, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x23, 0x0a, 0x0c, 0x61, 0x70, 0x70,
3464 0x65, 0x6e, 0x64, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x48,
3465 0x00, 0x52, 0x0b, 0x61, 0x70, 0x70, 0x65, 0x6e, 0x64, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x2b,
3466 0x0a, 0x10, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x6d, 0x6f, 0x75,
3467 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x0f, 0x69, 0x6e, 0x63, 0x72,
3468 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x06, 0x0a, 0x04, 0x72,
3469 0x75, 0x6c, 0x65, 0x22, 0x4c, 0x0a, 0x0f, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x50, 0x61, 0x72,
3470 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x39, 0x0a, 0x09, 0x72, 0x6f, 0x77, 0x5f, 0x72, 0x61,
3471 0x6e, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
3472 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x52,
3473 0x6f, 0x77, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x08, 0x72, 0x6f, 0x77, 0x52, 0x61, 0x6e, 0x67,
3474 0x65, 0x22, 0x5f, 0x0a, 0x18, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x43, 0x6f, 0x6e, 0x74, 0x69,
3475 0x6e, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x12, 0x43, 0x0a,
3476 0x06, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2b, 0x2e,
3477 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e,
3478 0x76, 0x32, 0x2e, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x43, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75,
3479 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x06, 0x74, 0x6f, 0x6b, 0x65,
3480 0x6e, 0x73, 0x22, 0x72, 0x0a, 0x17, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x43, 0x6f, 0x6e, 0x74,
3481 0x69, 0x6e, 0x75, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x41, 0x0a,
3482 0x09, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
3483 0x32, 0x23, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62,
3484 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x50, 0x61, 0x72, 0x74,
3485 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x09, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e,
3486 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
3487 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0x0d, 0x0a, 0x0b, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x46,
3488 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x22, 0x52, 0x0a, 0x0e, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4d,
3489 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18,
3490 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x2c, 0x0a, 0x04, 0x74,
3491 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
3492 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x54,
3493 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x4b, 0x0a, 0x0b, 0x50, 0x72, 0x6f,
3494 0x74, 0x6f, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x3c, 0x0a, 0x07, 0x63, 0x6f, 0x6c, 0x75,
3495 0x6d, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
3496 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x43,
3497 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x07, 0x63,
3498 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x22, 0x63, 0x0a, 0x11, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74,
3499 0x53, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x44, 0x0a, 0x0c, 0x70,
3500 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28,
3501 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61,
3502 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x53, 0x63, 0x68, 0x65,
3503 0x6d, 0x61, 0x48, 0x00, 0x52, 0x0b, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x53, 0x63, 0x68, 0x65, 0x6d,
3504 0x61, 0x42, 0x08, 0x0a, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, 0x3e, 0x0a, 0x09, 0x50,
3505 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x6f, 0x77, 0x73, 0x12, 0x31, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75,
3506 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
3507 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x2e, 0x56, 0x61,
3508 0x6c, 0x75, 0x65, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x22, 0x2f, 0x0a, 0x0e, 0x50,
3509 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x6f, 0x77, 0x73, 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, 0x1d, 0x0a,
3510 0x0a, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28,
3511 0x0c, 0x52, 0x09, 0x62, 0x61, 0x74, 0x63, 0x68, 0x44, 0x61, 0x74, 0x61, 0x22, 0x9c, 0x02, 0x0a,
3512 0x10, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x53, 0x65,
3513 0x74, 0x12, 0x4e, 0x0a, 0x10, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x72, 0x6f, 0x77, 0x73, 0x5f,
3514 0x62, 0x61, 0x74, 0x63, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x6f,
3515 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32,
3516 0x2e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x6f, 0x77, 0x73, 0x42, 0x61, 0x74, 0x63, 0x68, 0x48,
3517 0x00, 0x52, 0x0e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x6f, 0x77, 0x73, 0x42, 0x61, 0x74, 0x63,
3518 0x68, 0x12, 0x2a, 0x0a, 0x0e, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b,
3519 0x73, 0x75, 0x6d, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x48, 0x01, 0x52, 0x0d, 0x62, 0x61, 0x74,
3520 0x63, 0x68, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d, 0x88, 0x01, 0x01, 0x12, 0x21, 0x0a,
3521 0x0c, 0x72, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x05, 0x20,
3522 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x72, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e,
3523 0x12, 0x14, 0x0a, 0x05, 0x72, 0x65, 0x73, 0x65, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52,
3524 0x05, 0x72, 0x65, 0x73, 0x65, 0x74, 0x12, 0x30, 0x0a, 0x14, 0x65, 0x73, 0x74, 0x69, 0x6d, 0x61,
3525 0x74, 0x65, 0x64, 0x5f, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x04,
3526 0x20, 0x01, 0x28, 0x05, 0x52, 0x12, 0x65, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x64, 0x42,
3527 0x61, 0x74, 0x63, 0x68, 0x53, 0x69, 0x7a, 0x65, 0x42, 0x0e, 0x0a, 0x0c, 0x70, 0x61, 0x72, 0x74,
3528 0x69, 0x61, 0x6c, 0x5f, 0x72, 0x6f, 0x77, 0x73, 0x42, 0x11, 0x0a, 0x0f, 0x5f, 0x62, 0x61, 0x74,
3529 0x63, 0x68, 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d, 0x22, 0x5e, 0x0a, 0x0b, 0x49,
3530 0x64, 0x65, 0x6d, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f,
3531 0x6b, 0x65, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e,
3532 0x12, 0x39, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x02,
3533 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
3534 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
3535 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x42, 0xb3, 0x01, 0x0a, 0x16,
3536 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x62, 0x69, 0x67, 0x74, 0x61,
3537 0x62, 0x6c, 0x65, 0x2e, 0x76, 0x32, 0x42, 0x09, 0x44, 0x61, 0x74, 0x61, 0x50, 0x72, 0x6f, 0x74,
3538 0x6f, 0x50, 0x01, 0x5a, 0x38, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
3539 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x2f, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c,
3540 0x65, 0x2f, 0x61, 0x70, 0x69, 0x76, 0x32, 0x2f, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65,
3541 0x70, 0x62, 0x3b, 0x62, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x70, 0x62, 0xaa, 0x02, 0x18,
3542 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x2e, 0x42, 0x69, 0x67,
3543 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x56, 0x32, 0xca, 0x02, 0x18, 0x47, 0x6f, 0x6f, 0x67, 0x6c,
3544 0x65, 0x5c, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x5c, 0x42, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65,
3545 0x5c, 0x56, 0x32, 0xea, 0x02, 0x1b, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x3a, 0x3a, 0x43, 0x6c,
3546 0x6f, 0x75, 0x64, 0x3a, 0x3a, 0x42, 0x69, 0x67, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x3a, 0x3a, 0x56,
3547 0x32, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
3548 }
3549
3550 var (
3551 file_google_bigtable_v2_data_proto_rawDescOnce sync.Once
3552 file_google_bigtable_v2_data_proto_rawDescData = file_google_bigtable_v2_data_proto_rawDesc
3553 )
3554
3555 func file_google_bigtable_v2_data_proto_rawDescGZIP() []byte {
3556 file_google_bigtable_v2_data_proto_rawDescOnce.Do(func() {
3557 file_google_bigtable_v2_data_proto_rawDescData = protoimpl.X.CompressGZIP(file_google_bigtable_v2_data_proto_rawDescData)
3558 })
3559 return file_google_bigtable_v2_data_proto_rawDescData
3560 }
3561
3562 var file_google_bigtable_v2_data_proto_msgTypes = make([]protoimpl.MessageInfo, 34)
3563 var file_google_bigtable_v2_data_proto_goTypes = []any{
3564 (*Row)(nil), // 0: google.bigtable.v2.Row
3565 (*Family)(nil), // 1: google.bigtable.v2.Family
3566 (*Column)(nil), // 2: google.bigtable.v2.Column
3567 (*Cell)(nil), // 3: google.bigtable.v2.Cell
3568 (*Value)(nil), // 4: google.bigtable.v2.Value
3569 (*ArrayValue)(nil), // 5: google.bigtable.v2.ArrayValue
3570 (*RowRange)(nil), // 6: google.bigtable.v2.RowRange
3571 (*RowSet)(nil), // 7: google.bigtable.v2.RowSet
3572 (*ColumnRange)(nil), // 8: google.bigtable.v2.ColumnRange
3573 (*TimestampRange)(nil), // 9: google.bigtable.v2.TimestampRange
3574 (*ValueRange)(nil), // 10: google.bigtable.v2.ValueRange
3575 (*RowFilter)(nil), // 11: google.bigtable.v2.RowFilter
3576 (*Mutation)(nil), // 12: google.bigtable.v2.Mutation
3577 (*ReadModifyWriteRule)(nil), // 13: google.bigtable.v2.ReadModifyWriteRule
3578 (*StreamPartition)(nil), // 14: google.bigtable.v2.StreamPartition
3579 (*StreamContinuationTokens)(nil), // 15: google.bigtable.v2.StreamContinuationTokens
3580 (*StreamContinuationToken)(nil), // 16: google.bigtable.v2.StreamContinuationToken
3581 (*ProtoFormat)(nil), // 17: google.bigtable.v2.ProtoFormat
3582 (*ColumnMetadata)(nil), // 18: google.bigtable.v2.ColumnMetadata
3583 (*ProtoSchema)(nil), // 19: google.bigtable.v2.ProtoSchema
3584 (*ResultSetMetadata)(nil), // 20: google.bigtable.v2.ResultSetMetadata
3585 (*ProtoRows)(nil), // 21: google.bigtable.v2.ProtoRows
3586 (*ProtoRowsBatch)(nil), // 22: google.bigtable.v2.ProtoRowsBatch
3587 (*PartialResultSet)(nil), // 23: google.bigtable.v2.PartialResultSet
3588 (*Idempotency)(nil), // 24: google.bigtable.v2.Idempotency
3589 (*RowFilter_Chain)(nil), // 25: google.bigtable.v2.RowFilter.Chain
3590 (*RowFilter_Interleave)(nil), // 26: google.bigtable.v2.RowFilter.Interleave
3591 (*RowFilter_Condition)(nil), // 27: google.bigtable.v2.RowFilter.Condition
3592 (*Mutation_SetCell)(nil), // 28: google.bigtable.v2.Mutation.SetCell
3593 (*Mutation_AddToCell)(nil), // 29: google.bigtable.v2.Mutation.AddToCell
3594 (*Mutation_MergeToCell)(nil), // 30: google.bigtable.v2.Mutation.MergeToCell
3595 (*Mutation_DeleteFromColumn)(nil), // 31: google.bigtable.v2.Mutation.DeleteFromColumn
3596 (*Mutation_DeleteFromFamily)(nil), // 32: google.bigtable.v2.Mutation.DeleteFromFamily
3597 (*Mutation_DeleteFromRow)(nil), // 33: google.bigtable.v2.Mutation.DeleteFromRow
3598 (*Type)(nil), // 34: google.bigtable.v2.Type
3599 (*timestamppb.Timestamp)(nil), // 35: google.protobuf.Timestamp
3600 (*date.Date)(nil), // 36: google.type.Date
3601 }
3602 var file_google_bigtable_v2_data_proto_depIdxs = []int32{
3603 1, // 0: google.bigtable.v2.Row.families:type_name -> google.bigtable.v2.Family
3604 2, // 1: google.bigtable.v2.Family.columns:type_name -> google.bigtable.v2.Column
3605 3, // 2: google.bigtable.v2.Column.cells:type_name -> google.bigtable.v2.Cell
3606 34, // 3: google.bigtable.v2.Value.type:type_name -> google.bigtable.v2.Type
3607 35, // 4: google.bigtable.v2.Value.timestamp_value:type_name -> google.protobuf.Timestamp
3608 36, // 5: google.bigtable.v2.Value.date_value:type_name -> google.type.Date
3609 5, // 6: google.bigtable.v2.Value.array_value:type_name -> google.bigtable.v2.ArrayValue
3610 4, // 7: google.bigtable.v2.ArrayValue.values:type_name -> google.bigtable.v2.Value
3611 6, // 8: google.bigtable.v2.RowSet.row_ranges:type_name -> google.bigtable.v2.RowRange
3612 25, // 9: google.bigtable.v2.RowFilter.chain:type_name -> google.bigtable.v2.RowFilter.Chain
3613 26, // 10: google.bigtable.v2.RowFilter.interleave:type_name -> google.bigtable.v2.RowFilter.Interleave
3614 27, // 11: google.bigtable.v2.RowFilter.condition:type_name -> google.bigtable.v2.RowFilter.Condition
3615 8, // 12: google.bigtable.v2.RowFilter.column_range_filter:type_name -> google.bigtable.v2.ColumnRange
3616 9, // 13: google.bigtable.v2.RowFilter.timestamp_range_filter:type_name -> google.bigtable.v2.TimestampRange
3617 10, // 14: google.bigtable.v2.RowFilter.value_range_filter:type_name -> google.bigtable.v2.ValueRange
3618 28, // 15: google.bigtable.v2.Mutation.set_cell:type_name -> google.bigtable.v2.Mutation.SetCell
3619 29, // 16: google.bigtable.v2.Mutation.add_to_cell:type_name -> google.bigtable.v2.Mutation.AddToCell
3620 30, // 17: google.bigtable.v2.Mutation.merge_to_cell:type_name -> google.bigtable.v2.Mutation.MergeToCell
3621 31, // 18: google.bigtable.v2.Mutation.delete_from_column:type_name -> google.bigtable.v2.Mutation.DeleteFromColumn
3622 32, // 19: google.bigtable.v2.Mutation.delete_from_family:type_name -> google.bigtable.v2.Mutation.DeleteFromFamily
3623 33, // 20: google.bigtable.v2.Mutation.delete_from_row:type_name -> google.bigtable.v2.Mutation.DeleteFromRow
3624 6, // 21: google.bigtable.v2.StreamPartition.row_range:type_name -> google.bigtable.v2.RowRange
3625 16, // 22: google.bigtable.v2.StreamContinuationTokens.tokens:type_name -> google.bigtable.v2.StreamContinuationToken
3626 14, // 23: google.bigtable.v2.StreamContinuationToken.partition:type_name -> google.bigtable.v2.StreamPartition
3627 34, // 24: google.bigtable.v2.ColumnMetadata.type:type_name -> google.bigtable.v2.Type
3628 18, // 25: google.bigtable.v2.ProtoSchema.columns:type_name -> google.bigtable.v2.ColumnMetadata
3629 19, // 26: google.bigtable.v2.ResultSetMetadata.proto_schema:type_name -> google.bigtable.v2.ProtoSchema
3630 4, // 27: google.bigtable.v2.ProtoRows.values:type_name -> google.bigtable.v2.Value
3631 22, // 28: google.bigtable.v2.PartialResultSet.proto_rows_batch:type_name -> google.bigtable.v2.ProtoRowsBatch
3632 35, // 29: google.bigtable.v2.Idempotency.start_time:type_name -> google.protobuf.Timestamp
3633 11, // 30: google.bigtable.v2.RowFilter.Chain.filters:type_name -> google.bigtable.v2.RowFilter
3634 11, // 31: google.bigtable.v2.RowFilter.Interleave.filters:type_name -> google.bigtable.v2.RowFilter
3635 11, // 32: google.bigtable.v2.RowFilter.Condition.predicate_filter:type_name -> google.bigtable.v2.RowFilter
3636 11, // 33: google.bigtable.v2.RowFilter.Condition.true_filter:type_name -> google.bigtable.v2.RowFilter
3637 11, // 34: google.bigtable.v2.RowFilter.Condition.false_filter:type_name -> google.bigtable.v2.RowFilter
3638 4, // 35: google.bigtable.v2.Mutation.AddToCell.column_qualifier:type_name -> google.bigtable.v2.Value
3639 4, // 36: google.bigtable.v2.Mutation.AddToCell.timestamp:type_name -> google.bigtable.v2.Value
3640 4, // 37: google.bigtable.v2.Mutation.AddToCell.input:type_name -> google.bigtable.v2.Value
3641 4, // 38: google.bigtable.v2.Mutation.MergeToCell.column_qualifier:type_name -> google.bigtable.v2.Value
3642 4, // 39: google.bigtable.v2.Mutation.MergeToCell.timestamp:type_name -> google.bigtable.v2.Value
3643 4, // 40: google.bigtable.v2.Mutation.MergeToCell.input:type_name -> google.bigtable.v2.Value
3644 9, // 41: google.bigtable.v2.Mutation.DeleteFromColumn.time_range:type_name -> google.bigtable.v2.TimestampRange
3645 42, // [42:42] is the sub-list for method output_type
3646 42, // [42:42] is the sub-list for method input_type
3647 42, // [42:42] is the sub-list for extension type_name
3648 42, // [42:42] is the sub-list for extension extendee
3649 0, // [0:42] is the sub-list for field type_name
3650 }
3651
3652 func init() { file_google_bigtable_v2_data_proto_init() }
3653 func file_google_bigtable_v2_data_proto_init() {
3654 if File_google_bigtable_v2_data_proto != nil {
3655 return
3656 }
3657 file_google_bigtable_v2_types_proto_init()
3658 file_google_bigtable_v2_data_proto_msgTypes[4].OneofWrappers = []any{
3659 (*Value_RawValue)(nil),
3660 (*Value_RawTimestampMicros)(nil),
3661 (*Value_BytesValue)(nil),
3662 (*Value_StringValue)(nil),
3663 (*Value_IntValue)(nil),
3664 (*Value_BoolValue)(nil),
3665 (*Value_FloatValue)(nil),
3666 (*Value_TimestampValue)(nil),
3667 (*Value_DateValue)(nil),
3668 (*Value_ArrayValue)(nil),
3669 }
3670 file_google_bigtable_v2_data_proto_msgTypes[6].OneofWrappers = []any{
3671 (*RowRange_StartKeyClosed)(nil),
3672 (*RowRange_StartKeyOpen)(nil),
3673 (*RowRange_EndKeyOpen)(nil),
3674 (*RowRange_EndKeyClosed)(nil),
3675 }
3676 file_google_bigtable_v2_data_proto_msgTypes[8].OneofWrappers = []any{
3677 (*ColumnRange_StartQualifierClosed)(nil),
3678 (*ColumnRange_StartQualifierOpen)(nil),
3679 (*ColumnRange_EndQualifierClosed)(nil),
3680 (*ColumnRange_EndQualifierOpen)(nil),
3681 }
3682 file_google_bigtable_v2_data_proto_msgTypes[10].OneofWrappers = []any{
3683 (*ValueRange_StartValueClosed)(nil),
3684 (*ValueRange_StartValueOpen)(nil),
3685 (*ValueRange_EndValueClosed)(nil),
3686 (*ValueRange_EndValueOpen)(nil),
3687 }
3688 file_google_bigtable_v2_data_proto_msgTypes[11].OneofWrappers = []any{
3689 (*RowFilter_Chain_)(nil),
3690 (*RowFilter_Interleave_)(nil),
3691 (*RowFilter_Condition_)(nil),
3692 (*RowFilter_Sink)(nil),
3693 (*RowFilter_PassAllFilter)(nil),
3694 (*RowFilter_BlockAllFilter)(nil),
3695 (*RowFilter_RowKeyRegexFilter)(nil),
3696 (*RowFilter_RowSampleFilter)(nil),
3697 (*RowFilter_FamilyNameRegexFilter)(nil),
3698 (*RowFilter_ColumnQualifierRegexFilter)(nil),
3699 (*RowFilter_ColumnRangeFilter)(nil),
3700 (*RowFilter_TimestampRangeFilter)(nil),
3701 (*RowFilter_ValueRegexFilter)(nil),
3702 (*RowFilter_ValueRangeFilter)(nil),
3703 (*RowFilter_CellsPerRowOffsetFilter)(nil),
3704 (*RowFilter_CellsPerRowLimitFilter)(nil),
3705 (*RowFilter_CellsPerColumnLimitFilter)(nil),
3706 (*RowFilter_StripValueTransformer)(nil),
3707 (*RowFilter_ApplyLabelTransformer)(nil),
3708 }
3709 file_google_bigtable_v2_data_proto_msgTypes[12].OneofWrappers = []any{
3710 (*Mutation_SetCell_)(nil),
3711 (*Mutation_AddToCell_)(nil),
3712 (*Mutation_MergeToCell_)(nil),
3713 (*Mutation_DeleteFromColumn_)(nil),
3714 (*Mutation_DeleteFromFamily_)(nil),
3715 (*Mutation_DeleteFromRow_)(nil),
3716 }
3717 file_google_bigtable_v2_data_proto_msgTypes[13].OneofWrappers = []any{
3718 (*ReadModifyWriteRule_AppendValue)(nil),
3719 (*ReadModifyWriteRule_IncrementAmount)(nil),
3720 }
3721 file_google_bigtable_v2_data_proto_msgTypes[20].OneofWrappers = []any{
3722 (*ResultSetMetadata_ProtoSchema)(nil),
3723 }
3724 file_google_bigtable_v2_data_proto_msgTypes[23].OneofWrappers = []any{
3725 (*PartialResultSet_ProtoRowsBatch)(nil),
3726 }
3727 type x struct{}
3728 out := protoimpl.TypeBuilder{
3729 File: protoimpl.DescBuilder{
3730 GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
3731 RawDescriptor: file_google_bigtable_v2_data_proto_rawDesc,
3732 NumEnums: 0,
3733 NumMessages: 34,
3734 NumExtensions: 0,
3735 NumServices: 0,
3736 },
3737 GoTypes: file_google_bigtable_v2_data_proto_goTypes,
3738 DependencyIndexes: file_google_bigtable_v2_data_proto_depIdxs,
3739 MessageInfos: file_google_bigtable_v2_data_proto_msgTypes,
3740 }.Build()
3741 File_google_bigtable_v2_data_proto = out.File
3742 file_google_bigtable_v2_data_proto_rawDesc = nil
3743 file_google_bigtable_v2_data_proto_goTypes = nil
3744 file_google_bigtable_v2_data_proto_depIdxs = nil
3745 }