1 // Code generated by protoc-gen-go. DO NOT EDIT.
2 // source: google/bigtable/v1/bigtable_data.proto
5 Package bigtable is a generated protocol buffer package.
7 It is generated from these files:
8 google/bigtable/v1/bigtable_data.proto
9 google/bigtable/v1/bigtable_service.proto
10 google/bigtable/v1/bigtable_service_messages.proto
12 It has these top-level messages:
32 CheckAndMutateRowRequest
33 CheckAndMutateRowResponse
34 ReadModifyWriteRowRequest
38 import proto "github.com/golang/protobuf/proto"
42 // Reference imports to suppress errors if they are not otherwise used.
47 // This is a compile-time assertion to ensure that this generated file
48 // is compatible with the proto package it is being compiled against.
49 // A compilation error at this line likely means your copy of the
50 // proto package needs to be updated.
51 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
53 // Specifies the complete (requested) contents of a single row of a table.
54 // Rows which exceed 256MiB in size cannot be read in full.
56 // The unique key which identifies this row within its table. This is the same
57 // key that's used to identify the row in, for example, a MutateRowRequest.
58 // May contain any non-empty byte string up to 4KiB in length.
59 Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
60 // May be empty, but only if the entire row is empty.
61 // The mutual ordering of column families is not specified.
62 Families []*Family `protobuf:"bytes,2,rep,name=families" json:"families,omitempty"`
65 func (m *Row) Reset() { *m = Row{} }
66 func (m *Row) String() string { return proto.CompactTextString(m) }
67 func (*Row) ProtoMessage() {}
68 func (*Row) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
70 func (m *Row) GetKey() []byte {
77 func (m *Row) GetFamilies() []*Family {
84 // Specifies (some of) the contents of a single row/column family of a table.
86 // The unique key which identifies this family within its row. This is the
87 // same key that's used to identify the family in, for example, a RowFilter
88 // which sets its "family_name_regex_filter" field.
89 // Must match [-_.a-zA-Z0-9]+, except that AggregatingRowProcessors may
90 // produce cells in a sentinel family with an empty name.
91 // Must be no greater than 64 characters in length.
92 Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
93 // Must not be empty. Sorted in order of increasing "qualifier".
94 Columns []*Column `protobuf:"bytes,2,rep,name=columns" json:"columns,omitempty"`
97 func (m *Family) Reset() { *m = Family{} }
98 func (m *Family) String() string { return proto.CompactTextString(m) }
99 func (*Family) ProtoMessage() {}
100 func (*Family) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
102 func (m *Family) GetName() string {
109 func (m *Family) GetColumns() []*Column {
116 // Specifies (some of) the contents of a single row/column of a table.
118 // The unique key which identifies this column within its family. This is the
119 // same key that's used to identify the column in, for example, a RowFilter
120 // which sets its "column_qualifier_regex_filter" field.
121 // May contain any byte string, including the empty string, up to 16kiB in
123 Qualifier []byte `protobuf:"bytes,1,opt,name=qualifier,proto3" json:"qualifier,omitempty"`
124 // Must not be empty. Sorted in order of decreasing "timestamp_micros".
125 Cells []*Cell `protobuf:"bytes,2,rep,name=cells" json:"cells,omitempty"`
128 func (m *Column) Reset() { *m = Column{} }
129 func (m *Column) String() string { return proto.CompactTextString(m) }
130 func (*Column) ProtoMessage() {}
131 func (*Column) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
133 func (m *Column) GetQualifier() []byte {
140 func (m *Column) GetCells() []*Cell {
147 // Specifies (some of) the contents of a single row/column/timestamp of a table.
149 // The cell's stored timestamp, which also uniquely identifies it within
151 // Values are always expressed in microseconds, but individual tables may set
152 // a coarser "granularity" to further restrict the allowed values. For
153 // example, a table which specifies millisecond granularity will only allow
154 // values of "timestamp_micros" which are multiples of 1000.
155 TimestampMicros int64 `protobuf:"varint,1,opt,name=timestamp_micros,json=timestampMicros" json:"timestamp_micros,omitempty"`
156 // The value stored in the cell.
157 // May contain any byte string, including the empty string, up to 100MiB in
159 Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
160 // Labels applied to the cell by a [RowFilter][google.bigtable.v1.RowFilter].
161 Labels []string `protobuf:"bytes,3,rep,name=labels" json:"labels,omitempty"`
164 func (m *Cell) Reset() { *m = Cell{} }
165 func (m *Cell) String() string { return proto.CompactTextString(m) }
166 func (*Cell) ProtoMessage() {}
167 func (*Cell) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
169 func (m *Cell) GetTimestampMicros() int64 {
171 return m.TimestampMicros
176 func (m *Cell) GetValue() []byte {
183 func (m *Cell) GetLabels() []string {
190 // Specifies a contiguous range of rows.
191 type RowRange struct {
192 // Inclusive lower bound. If left empty, interpreted as the empty string.
193 StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"`
194 // Exclusive upper bound. If left empty, interpreted as infinity.
195 EndKey []byte `protobuf:"bytes,3,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"`
198 func (m *RowRange) Reset() { *m = RowRange{} }
199 func (m *RowRange) String() string { return proto.CompactTextString(m) }
200 func (*RowRange) ProtoMessage() {}
201 func (*RowRange) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
203 func (m *RowRange) GetStartKey() []byte {
210 func (m *RowRange) GetEndKey() []byte {
217 // Specifies a non-contiguous set of rows.
219 // Single rows included in the set.
220 RowKeys [][]byte `protobuf:"bytes,1,rep,name=row_keys,json=rowKeys,proto3" json:"row_keys,omitempty"`
221 // Contiguous row ranges included in the set.
222 RowRanges []*RowRange `protobuf:"bytes,2,rep,name=row_ranges,json=rowRanges" json:"row_ranges,omitempty"`
225 func (m *RowSet) Reset() { *m = RowSet{} }
226 func (m *RowSet) String() string { return proto.CompactTextString(m) }
227 func (*RowSet) ProtoMessage() {}
228 func (*RowSet) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
230 func (m *RowSet) GetRowKeys() [][]byte {
237 func (m *RowSet) GetRowRanges() []*RowRange {
244 // Specifies a contiguous range of columns within a single column family.
245 // The range spans from <column_family>:<start_qualifier> to
246 // <column_family>:<end_qualifier>, where both bounds can be either inclusive or
248 type ColumnRange struct {
249 // The name of the column family within which this range falls.
250 FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName" json:"family_name,omitempty"`
251 // The column qualifier at which to start the range (within 'column_family').
252 // If neither field is set, interpreted as the empty string, inclusive.
254 // Types that are valid to be assigned to StartQualifier:
255 // *ColumnRange_StartQualifierInclusive
256 // *ColumnRange_StartQualifierExclusive
257 StartQualifier isColumnRange_StartQualifier `protobuf_oneof:"start_qualifier"`
258 // The column qualifier at which to end the range (within 'column_family').
259 // If neither field is set, interpreted as the infinite string, exclusive.
261 // Types that are valid to be assigned to EndQualifier:
262 // *ColumnRange_EndQualifierInclusive
263 // *ColumnRange_EndQualifierExclusive
264 EndQualifier isColumnRange_EndQualifier `protobuf_oneof:"end_qualifier"`
267 func (m *ColumnRange) Reset() { *m = ColumnRange{} }
268 func (m *ColumnRange) String() string { return proto.CompactTextString(m) }
269 func (*ColumnRange) ProtoMessage() {}
270 func (*ColumnRange) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
272 type isColumnRange_StartQualifier interface {
273 isColumnRange_StartQualifier()
275 type isColumnRange_EndQualifier interface {
276 isColumnRange_EndQualifier()
279 type ColumnRange_StartQualifierInclusive struct {
280 StartQualifierInclusive []byte `protobuf:"bytes,2,opt,name=start_qualifier_inclusive,json=startQualifierInclusive,proto3,oneof"`
282 type ColumnRange_StartQualifierExclusive struct {
283 StartQualifierExclusive []byte `protobuf:"bytes,3,opt,name=start_qualifier_exclusive,json=startQualifierExclusive,proto3,oneof"`
285 type ColumnRange_EndQualifierInclusive struct {
286 EndQualifierInclusive []byte `protobuf:"bytes,4,opt,name=end_qualifier_inclusive,json=endQualifierInclusive,proto3,oneof"`
288 type ColumnRange_EndQualifierExclusive struct {
289 EndQualifierExclusive []byte `protobuf:"bytes,5,opt,name=end_qualifier_exclusive,json=endQualifierExclusive,proto3,oneof"`
292 func (*ColumnRange_StartQualifierInclusive) isColumnRange_StartQualifier() {}
293 func (*ColumnRange_StartQualifierExclusive) isColumnRange_StartQualifier() {}
294 func (*ColumnRange_EndQualifierInclusive) isColumnRange_EndQualifier() {}
295 func (*ColumnRange_EndQualifierExclusive) isColumnRange_EndQualifier() {}
297 func (m *ColumnRange) GetStartQualifier() isColumnRange_StartQualifier {
299 return m.StartQualifier
303 func (m *ColumnRange) GetEndQualifier() isColumnRange_EndQualifier {
305 return m.EndQualifier
310 func (m *ColumnRange) GetFamilyName() string {
317 func (m *ColumnRange) GetStartQualifierInclusive() []byte {
318 if x, ok := m.GetStartQualifier().(*ColumnRange_StartQualifierInclusive); ok {
319 return x.StartQualifierInclusive
324 func (m *ColumnRange) GetStartQualifierExclusive() []byte {
325 if x, ok := m.GetStartQualifier().(*ColumnRange_StartQualifierExclusive); ok {
326 return x.StartQualifierExclusive
331 func (m *ColumnRange) GetEndQualifierInclusive() []byte {
332 if x, ok := m.GetEndQualifier().(*ColumnRange_EndQualifierInclusive); ok {
333 return x.EndQualifierInclusive
338 func (m *ColumnRange) GetEndQualifierExclusive() []byte {
339 if x, ok := m.GetEndQualifier().(*ColumnRange_EndQualifierExclusive); ok {
340 return x.EndQualifierExclusive
345 // XXX_OneofFuncs is for the internal use of the proto package.
346 func (*ColumnRange) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
347 return _ColumnRange_OneofMarshaler, _ColumnRange_OneofUnmarshaler, _ColumnRange_OneofSizer, []interface{}{
348 (*ColumnRange_StartQualifierInclusive)(nil),
349 (*ColumnRange_StartQualifierExclusive)(nil),
350 (*ColumnRange_EndQualifierInclusive)(nil),
351 (*ColumnRange_EndQualifierExclusive)(nil),
355 func _ColumnRange_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
356 m := msg.(*ColumnRange)
358 switch x := m.StartQualifier.(type) {
359 case *ColumnRange_StartQualifierInclusive:
360 b.EncodeVarint(2<<3 | proto.WireBytes)
361 b.EncodeRawBytes(x.StartQualifierInclusive)
362 case *ColumnRange_StartQualifierExclusive:
363 b.EncodeVarint(3<<3 | proto.WireBytes)
364 b.EncodeRawBytes(x.StartQualifierExclusive)
367 return fmt.Errorf("ColumnRange.StartQualifier has unexpected type %T", x)
370 switch x := m.EndQualifier.(type) {
371 case *ColumnRange_EndQualifierInclusive:
372 b.EncodeVarint(4<<3 | proto.WireBytes)
373 b.EncodeRawBytes(x.EndQualifierInclusive)
374 case *ColumnRange_EndQualifierExclusive:
375 b.EncodeVarint(5<<3 | proto.WireBytes)
376 b.EncodeRawBytes(x.EndQualifierExclusive)
379 return fmt.Errorf("ColumnRange.EndQualifier has unexpected type %T", x)
384 func _ColumnRange_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
385 m := msg.(*ColumnRange)
387 case 2: // start_qualifier.start_qualifier_inclusive
388 if wire != proto.WireBytes {
389 return true, proto.ErrInternalBadWireType
391 x, err := b.DecodeRawBytes(true)
392 m.StartQualifier = &ColumnRange_StartQualifierInclusive{x}
394 case 3: // start_qualifier.start_qualifier_exclusive
395 if wire != proto.WireBytes {
396 return true, proto.ErrInternalBadWireType
398 x, err := b.DecodeRawBytes(true)
399 m.StartQualifier = &ColumnRange_StartQualifierExclusive{x}
401 case 4: // end_qualifier.end_qualifier_inclusive
402 if wire != proto.WireBytes {
403 return true, proto.ErrInternalBadWireType
405 x, err := b.DecodeRawBytes(true)
406 m.EndQualifier = &ColumnRange_EndQualifierInclusive{x}
408 case 5: // end_qualifier.end_qualifier_exclusive
409 if wire != proto.WireBytes {
410 return true, proto.ErrInternalBadWireType
412 x, err := b.DecodeRawBytes(true)
413 m.EndQualifier = &ColumnRange_EndQualifierExclusive{x}
420 func _ColumnRange_OneofSizer(msg proto.Message) (n int) {
421 m := msg.(*ColumnRange)
423 switch x := m.StartQualifier.(type) {
424 case *ColumnRange_StartQualifierInclusive:
425 n += proto.SizeVarint(2<<3 | proto.WireBytes)
426 n += proto.SizeVarint(uint64(len(x.StartQualifierInclusive)))
427 n += len(x.StartQualifierInclusive)
428 case *ColumnRange_StartQualifierExclusive:
429 n += proto.SizeVarint(3<<3 | proto.WireBytes)
430 n += proto.SizeVarint(uint64(len(x.StartQualifierExclusive)))
431 n += len(x.StartQualifierExclusive)
434 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
437 switch x := m.EndQualifier.(type) {
438 case *ColumnRange_EndQualifierInclusive:
439 n += proto.SizeVarint(4<<3 | proto.WireBytes)
440 n += proto.SizeVarint(uint64(len(x.EndQualifierInclusive)))
441 n += len(x.EndQualifierInclusive)
442 case *ColumnRange_EndQualifierExclusive:
443 n += proto.SizeVarint(5<<3 | proto.WireBytes)
444 n += proto.SizeVarint(uint64(len(x.EndQualifierExclusive)))
445 n += len(x.EndQualifierExclusive)
448 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
453 // Specified a contiguous range of microsecond timestamps.
454 type TimestampRange struct {
455 // Inclusive lower bound. If left empty, interpreted as 0.
456 StartTimestampMicros int64 `protobuf:"varint,1,opt,name=start_timestamp_micros,json=startTimestampMicros" json:"start_timestamp_micros,omitempty"`
457 // Exclusive upper bound. If left empty, interpreted as infinity.
458 EndTimestampMicros int64 `protobuf:"varint,2,opt,name=end_timestamp_micros,json=endTimestampMicros" json:"end_timestamp_micros,omitempty"`
461 func (m *TimestampRange) Reset() { *m = TimestampRange{} }
462 func (m *TimestampRange) String() string { return proto.CompactTextString(m) }
463 func (*TimestampRange) ProtoMessage() {}
464 func (*TimestampRange) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
466 func (m *TimestampRange) GetStartTimestampMicros() int64 {
468 return m.StartTimestampMicros
473 func (m *TimestampRange) GetEndTimestampMicros() int64 {
475 return m.EndTimestampMicros
480 // Specifies a contiguous range of raw byte values.
481 type ValueRange struct {
482 // The value at which to start the range.
483 // If neither field is set, interpreted as the empty string, inclusive.
485 // Types that are valid to be assigned to StartValue:
486 // *ValueRange_StartValueInclusive
487 // *ValueRange_StartValueExclusive
488 StartValue isValueRange_StartValue `protobuf_oneof:"start_value"`
489 // The value at which to end the range.
490 // If neither field is set, interpreted as the infinite string, exclusive.
492 // Types that are valid to be assigned to EndValue:
493 // *ValueRange_EndValueInclusive
494 // *ValueRange_EndValueExclusive
495 EndValue isValueRange_EndValue `protobuf_oneof:"end_value"`
498 func (m *ValueRange) Reset() { *m = ValueRange{} }
499 func (m *ValueRange) String() string { return proto.CompactTextString(m) }
500 func (*ValueRange) ProtoMessage() {}
501 func (*ValueRange) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
503 type isValueRange_StartValue interface {
504 isValueRange_StartValue()
506 type isValueRange_EndValue interface {
507 isValueRange_EndValue()
510 type ValueRange_StartValueInclusive struct {
511 StartValueInclusive []byte `protobuf:"bytes,1,opt,name=start_value_inclusive,json=startValueInclusive,proto3,oneof"`
513 type ValueRange_StartValueExclusive struct {
514 StartValueExclusive []byte `protobuf:"bytes,2,opt,name=start_value_exclusive,json=startValueExclusive,proto3,oneof"`
516 type ValueRange_EndValueInclusive struct {
517 EndValueInclusive []byte `protobuf:"bytes,3,opt,name=end_value_inclusive,json=endValueInclusive,proto3,oneof"`
519 type ValueRange_EndValueExclusive struct {
520 EndValueExclusive []byte `protobuf:"bytes,4,opt,name=end_value_exclusive,json=endValueExclusive,proto3,oneof"`
523 func (*ValueRange_StartValueInclusive) isValueRange_StartValue() {}
524 func (*ValueRange_StartValueExclusive) isValueRange_StartValue() {}
525 func (*ValueRange_EndValueInclusive) isValueRange_EndValue() {}
526 func (*ValueRange_EndValueExclusive) isValueRange_EndValue() {}
528 func (m *ValueRange) GetStartValue() isValueRange_StartValue {
534 func (m *ValueRange) GetEndValue() isValueRange_EndValue {
541 func (m *ValueRange) GetStartValueInclusive() []byte {
542 if x, ok := m.GetStartValue().(*ValueRange_StartValueInclusive); ok {
543 return x.StartValueInclusive
548 func (m *ValueRange) GetStartValueExclusive() []byte {
549 if x, ok := m.GetStartValue().(*ValueRange_StartValueExclusive); ok {
550 return x.StartValueExclusive
555 func (m *ValueRange) GetEndValueInclusive() []byte {
556 if x, ok := m.GetEndValue().(*ValueRange_EndValueInclusive); ok {
557 return x.EndValueInclusive
562 func (m *ValueRange) GetEndValueExclusive() []byte {
563 if x, ok := m.GetEndValue().(*ValueRange_EndValueExclusive); ok {
564 return x.EndValueExclusive
569 // XXX_OneofFuncs is for the internal use of the proto package.
570 func (*ValueRange) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
571 return _ValueRange_OneofMarshaler, _ValueRange_OneofUnmarshaler, _ValueRange_OneofSizer, []interface{}{
572 (*ValueRange_StartValueInclusive)(nil),
573 (*ValueRange_StartValueExclusive)(nil),
574 (*ValueRange_EndValueInclusive)(nil),
575 (*ValueRange_EndValueExclusive)(nil),
579 func _ValueRange_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
580 m := msg.(*ValueRange)
582 switch x := m.StartValue.(type) {
583 case *ValueRange_StartValueInclusive:
584 b.EncodeVarint(1<<3 | proto.WireBytes)
585 b.EncodeRawBytes(x.StartValueInclusive)
586 case *ValueRange_StartValueExclusive:
587 b.EncodeVarint(2<<3 | proto.WireBytes)
588 b.EncodeRawBytes(x.StartValueExclusive)
591 return fmt.Errorf("ValueRange.StartValue has unexpected type %T", x)
594 switch x := m.EndValue.(type) {
595 case *ValueRange_EndValueInclusive:
596 b.EncodeVarint(3<<3 | proto.WireBytes)
597 b.EncodeRawBytes(x.EndValueInclusive)
598 case *ValueRange_EndValueExclusive:
599 b.EncodeVarint(4<<3 | proto.WireBytes)
600 b.EncodeRawBytes(x.EndValueExclusive)
603 return fmt.Errorf("ValueRange.EndValue has unexpected type %T", x)
608 func _ValueRange_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
609 m := msg.(*ValueRange)
611 case 1: // start_value.start_value_inclusive
612 if wire != proto.WireBytes {
613 return true, proto.ErrInternalBadWireType
615 x, err := b.DecodeRawBytes(true)
616 m.StartValue = &ValueRange_StartValueInclusive{x}
618 case 2: // start_value.start_value_exclusive
619 if wire != proto.WireBytes {
620 return true, proto.ErrInternalBadWireType
622 x, err := b.DecodeRawBytes(true)
623 m.StartValue = &ValueRange_StartValueExclusive{x}
625 case 3: // end_value.end_value_inclusive
626 if wire != proto.WireBytes {
627 return true, proto.ErrInternalBadWireType
629 x, err := b.DecodeRawBytes(true)
630 m.EndValue = &ValueRange_EndValueInclusive{x}
632 case 4: // end_value.end_value_exclusive
633 if wire != proto.WireBytes {
634 return true, proto.ErrInternalBadWireType
636 x, err := b.DecodeRawBytes(true)
637 m.EndValue = &ValueRange_EndValueExclusive{x}
644 func _ValueRange_OneofSizer(msg proto.Message) (n int) {
645 m := msg.(*ValueRange)
647 switch x := m.StartValue.(type) {
648 case *ValueRange_StartValueInclusive:
649 n += proto.SizeVarint(1<<3 | proto.WireBytes)
650 n += proto.SizeVarint(uint64(len(x.StartValueInclusive)))
651 n += len(x.StartValueInclusive)
652 case *ValueRange_StartValueExclusive:
653 n += proto.SizeVarint(2<<3 | proto.WireBytes)
654 n += proto.SizeVarint(uint64(len(x.StartValueExclusive)))
655 n += len(x.StartValueExclusive)
658 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
661 switch x := m.EndValue.(type) {
662 case *ValueRange_EndValueInclusive:
663 n += proto.SizeVarint(3<<3 | proto.WireBytes)
664 n += proto.SizeVarint(uint64(len(x.EndValueInclusive)))
665 n += len(x.EndValueInclusive)
666 case *ValueRange_EndValueExclusive:
667 n += proto.SizeVarint(4<<3 | proto.WireBytes)
668 n += proto.SizeVarint(uint64(len(x.EndValueExclusive)))
669 n += len(x.EndValueExclusive)
672 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
677 // Takes a row as input and produces an alternate view of the row based on
678 // specified rules. For example, a RowFilter might trim down a row to include
679 // just the cells from columns matching a given regular expression, or might
680 // return all the cells of a row but not their values. More complicated filters
681 // can be composed out of these components to express requests such as, "within
682 // every column of a particular family, give just the two most recent cells
683 // which are older than timestamp X."
685 // There are two broad categories of RowFilters (true filters and transformers),
686 // as well as two ways to compose simple filters into more complex ones
687 // (chains and interleaves). They work as follows:
689 // * True filters alter the input row by excluding some of its cells wholesale
690 // from the output row. An example of a true filter is the "value_regex_filter",
691 // which excludes cells whose values don't match the specified pattern. All
692 // regex true filters use RE2 syntax (https://github.com/google/re2/wiki/Syntax)
693 // in raw byte mode (RE2::Latin1), and are evaluated as full matches. An
694 // important point to keep in mind is that RE2(.) is equivalent by default to
695 // RE2([^\n]), meaning that it does not match newlines. When attempting to match
696 // an arbitrary byte, you should therefore use the escape sequence '\C', which
697 // may need to be further escaped as '\\C' in your client language.
699 // * Transformers alter the input row by changing the values of some of its
700 // cells in the output, without excluding them completely. Currently, the only
701 // supported transformer is the "strip_value_transformer", which replaces every
702 // cell's value with the empty string.
704 // * Chains and interleaves are described in more detail in the
705 // RowFilter.Chain and RowFilter.Interleave documentation.
707 // The total serialized size of a RowFilter message must not
708 // exceed 4096 bytes, and RowFilters may not be nested within each other
709 // (in Chains or Interleaves) to a depth of more than 20.
710 type RowFilter struct {
711 // Which of the possible RowFilter types to apply. If none are set, this
712 // RowFilter returns all cells in the input row.
714 // Types that are valid to be assigned to Filter:
716 // *RowFilter_Interleave_
717 // *RowFilter_Condition_
719 // *RowFilter_PassAllFilter
720 // *RowFilter_BlockAllFilter
721 // *RowFilter_RowKeyRegexFilter
722 // *RowFilter_RowSampleFilter
723 // *RowFilter_FamilyNameRegexFilter
724 // *RowFilter_ColumnQualifierRegexFilter
725 // *RowFilter_ColumnRangeFilter
726 // *RowFilter_TimestampRangeFilter
727 // *RowFilter_ValueRegexFilter
728 // *RowFilter_ValueRangeFilter
729 // *RowFilter_CellsPerRowOffsetFilter
730 // *RowFilter_CellsPerRowLimitFilter
731 // *RowFilter_CellsPerColumnLimitFilter
732 // *RowFilter_StripValueTransformer
733 // *RowFilter_ApplyLabelTransformer
734 Filter isRowFilter_Filter `protobuf_oneof:"filter"`
737 func (m *RowFilter) Reset() { *m = RowFilter{} }
738 func (m *RowFilter) String() string { return proto.CompactTextString(m) }
739 func (*RowFilter) ProtoMessage() {}
740 func (*RowFilter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
742 type isRowFilter_Filter interface {
746 type RowFilter_Chain_ struct {
747 Chain *RowFilter_Chain `protobuf:"bytes,1,opt,name=chain,oneof"`
749 type RowFilter_Interleave_ struct {
750 Interleave *RowFilter_Interleave `protobuf:"bytes,2,opt,name=interleave,oneof"`
752 type RowFilter_Condition_ struct {
753 Condition *RowFilter_Condition `protobuf:"bytes,3,opt,name=condition,oneof"`
755 type RowFilter_Sink struct {
756 Sink bool `protobuf:"varint,16,opt,name=sink,oneof"`
758 type RowFilter_PassAllFilter struct {
759 PassAllFilter bool `protobuf:"varint,17,opt,name=pass_all_filter,json=passAllFilter,oneof"`
761 type RowFilter_BlockAllFilter struct {
762 BlockAllFilter bool `protobuf:"varint,18,opt,name=block_all_filter,json=blockAllFilter,oneof"`
764 type RowFilter_RowKeyRegexFilter struct {
765 RowKeyRegexFilter []byte `protobuf:"bytes,4,opt,name=row_key_regex_filter,json=rowKeyRegexFilter,proto3,oneof"`
767 type RowFilter_RowSampleFilter struct {
768 RowSampleFilter float64 `protobuf:"fixed64,14,opt,name=row_sample_filter,json=rowSampleFilter,oneof"`
770 type RowFilter_FamilyNameRegexFilter struct {
771 FamilyNameRegexFilter string `protobuf:"bytes,5,opt,name=family_name_regex_filter,json=familyNameRegexFilter,oneof"`
773 type RowFilter_ColumnQualifierRegexFilter struct {
774 ColumnQualifierRegexFilter []byte `protobuf:"bytes,6,opt,name=column_qualifier_regex_filter,json=columnQualifierRegexFilter,proto3,oneof"`
776 type RowFilter_ColumnRangeFilter struct {
777 ColumnRangeFilter *ColumnRange `protobuf:"bytes,7,opt,name=column_range_filter,json=columnRangeFilter,oneof"`
779 type RowFilter_TimestampRangeFilter struct {
780 TimestampRangeFilter *TimestampRange `protobuf:"bytes,8,opt,name=timestamp_range_filter,json=timestampRangeFilter,oneof"`
782 type RowFilter_ValueRegexFilter struct {
783 ValueRegexFilter []byte `protobuf:"bytes,9,opt,name=value_regex_filter,json=valueRegexFilter,proto3,oneof"`
785 type RowFilter_ValueRangeFilter struct {
786 ValueRangeFilter *ValueRange `protobuf:"bytes,15,opt,name=value_range_filter,json=valueRangeFilter,oneof"`
788 type RowFilter_CellsPerRowOffsetFilter struct {
789 CellsPerRowOffsetFilter int32 `protobuf:"varint,10,opt,name=cells_per_row_offset_filter,json=cellsPerRowOffsetFilter,oneof"`
791 type RowFilter_CellsPerRowLimitFilter struct {
792 CellsPerRowLimitFilter int32 `protobuf:"varint,11,opt,name=cells_per_row_limit_filter,json=cellsPerRowLimitFilter,oneof"`
794 type RowFilter_CellsPerColumnLimitFilter struct {
795 CellsPerColumnLimitFilter int32 `protobuf:"varint,12,opt,name=cells_per_column_limit_filter,json=cellsPerColumnLimitFilter,oneof"`
797 type RowFilter_StripValueTransformer struct {
798 StripValueTransformer bool `protobuf:"varint,13,opt,name=strip_value_transformer,json=stripValueTransformer,oneof"`
800 type RowFilter_ApplyLabelTransformer struct {
801 ApplyLabelTransformer string `protobuf:"bytes,19,opt,name=apply_label_transformer,json=applyLabelTransformer,oneof"`
804 func (*RowFilter_Chain_) isRowFilter_Filter() {}
805 func (*RowFilter_Interleave_) isRowFilter_Filter() {}
806 func (*RowFilter_Condition_) isRowFilter_Filter() {}
807 func (*RowFilter_Sink) isRowFilter_Filter() {}
808 func (*RowFilter_PassAllFilter) isRowFilter_Filter() {}
809 func (*RowFilter_BlockAllFilter) isRowFilter_Filter() {}
810 func (*RowFilter_RowKeyRegexFilter) isRowFilter_Filter() {}
811 func (*RowFilter_RowSampleFilter) isRowFilter_Filter() {}
812 func (*RowFilter_FamilyNameRegexFilter) isRowFilter_Filter() {}
813 func (*RowFilter_ColumnQualifierRegexFilter) isRowFilter_Filter() {}
814 func (*RowFilter_ColumnRangeFilter) isRowFilter_Filter() {}
815 func (*RowFilter_TimestampRangeFilter) isRowFilter_Filter() {}
816 func (*RowFilter_ValueRegexFilter) isRowFilter_Filter() {}
817 func (*RowFilter_ValueRangeFilter) isRowFilter_Filter() {}
818 func (*RowFilter_CellsPerRowOffsetFilter) isRowFilter_Filter() {}
819 func (*RowFilter_CellsPerRowLimitFilter) isRowFilter_Filter() {}
820 func (*RowFilter_CellsPerColumnLimitFilter) isRowFilter_Filter() {}
821 func (*RowFilter_StripValueTransformer) isRowFilter_Filter() {}
822 func (*RowFilter_ApplyLabelTransformer) isRowFilter_Filter() {}
824 func (m *RowFilter) GetFilter() isRowFilter_Filter {
831 func (m *RowFilter) GetChain() *RowFilter_Chain {
832 if x, ok := m.GetFilter().(*RowFilter_Chain_); ok {
838 func (m *RowFilter) GetInterleave() *RowFilter_Interleave {
839 if x, ok := m.GetFilter().(*RowFilter_Interleave_); ok {
845 func (m *RowFilter) GetCondition() *RowFilter_Condition {
846 if x, ok := m.GetFilter().(*RowFilter_Condition_); ok {
852 func (m *RowFilter) GetSink() bool {
853 if x, ok := m.GetFilter().(*RowFilter_Sink); ok {
859 func (m *RowFilter) GetPassAllFilter() bool {
860 if x, ok := m.GetFilter().(*RowFilter_PassAllFilter); ok {
861 return x.PassAllFilter
866 func (m *RowFilter) GetBlockAllFilter() bool {
867 if x, ok := m.GetFilter().(*RowFilter_BlockAllFilter); ok {
868 return x.BlockAllFilter
873 func (m *RowFilter) GetRowKeyRegexFilter() []byte {
874 if x, ok := m.GetFilter().(*RowFilter_RowKeyRegexFilter); ok {
875 return x.RowKeyRegexFilter
880 func (m *RowFilter) GetRowSampleFilter() float64 {
881 if x, ok := m.GetFilter().(*RowFilter_RowSampleFilter); ok {
882 return x.RowSampleFilter
887 func (m *RowFilter) GetFamilyNameRegexFilter() string {
888 if x, ok := m.GetFilter().(*RowFilter_FamilyNameRegexFilter); ok {
889 return x.FamilyNameRegexFilter
894 func (m *RowFilter) GetColumnQualifierRegexFilter() []byte {
895 if x, ok := m.GetFilter().(*RowFilter_ColumnQualifierRegexFilter); ok {
896 return x.ColumnQualifierRegexFilter
901 func (m *RowFilter) GetColumnRangeFilter() *ColumnRange {
902 if x, ok := m.GetFilter().(*RowFilter_ColumnRangeFilter); ok {
903 return x.ColumnRangeFilter
908 func (m *RowFilter) GetTimestampRangeFilter() *TimestampRange {
909 if x, ok := m.GetFilter().(*RowFilter_TimestampRangeFilter); ok {
910 return x.TimestampRangeFilter
915 func (m *RowFilter) GetValueRegexFilter() []byte {
916 if x, ok := m.GetFilter().(*RowFilter_ValueRegexFilter); ok {
917 return x.ValueRegexFilter
922 func (m *RowFilter) GetValueRangeFilter() *ValueRange {
923 if x, ok := m.GetFilter().(*RowFilter_ValueRangeFilter); ok {
924 return x.ValueRangeFilter
929 func (m *RowFilter) GetCellsPerRowOffsetFilter() int32 {
930 if x, ok := m.GetFilter().(*RowFilter_CellsPerRowOffsetFilter); ok {
931 return x.CellsPerRowOffsetFilter
936 func (m *RowFilter) GetCellsPerRowLimitFilter() int32 {
937 if x, ok := m.GetFilter().(*RowFilter_CellsPerRowLimitFilter); ok {
938 return x.CellsPerRowLimitFilter
943 func (m *RowFilter) GetCellsPerColumnLimitFilter() int32 {
944 if x, ok := m.GetFilter().(*RowFilter_CellsPerColumnLimitFilter); ok {
945 return x.CellsPerColumnLimitFilter
950 func (m *RowFilter) GetStripValueTransformer() bool {
951 if x, ok := m.GetFilter().(*RowFilter_StripValueTransformer); ok {
952 return x.StripValueTransformer
957 func (m *RowFilter) GetApplyLabelTransformer() string {
958 if x, ok := m.GetFilter().(*RowFilter_ApplyLabelTransformer); ok {
959 return x.ApplyLabelTransformer
964 // XXX_OneofFuncs is for the internal use of the proto package.
965 func (*RowFilter) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
966 return _RowFilter_OneofMarshaler, _RowFilter_OneofUnmarshaler, _RowFilter_OneofSizer, []interface{}{
967 (*RowFilter_Chain_)(nil),
968 (*RowFilter_Interleave_)(nil),
969 (*RowFilter_Condition_)(nil),
970 (*RowFilter_Sink)(nil),
971 (*RowFilter_PassAllFilter)(nil),
972 (*RowFilter_BlockAllFilter)(nil),
973 (*RowFilter_RowKeyRegexFilter)(nil),
974 (*RowFilter_RowSampleFilter)(nil),
975 (*RowFilter_FamilyNameRegexFilter)(nil),
976 (*RowFilter_ColumnQualifierRegexFilter)(nil),
977 (*RowFilter_ColumnRangeFilter)(nil),
978 (*RowFilter_TimestampRangeFilter)(nil),
979 (*RowFilter_ValueRegexFilter)(nil),
980 (*RowFilter_ValueRangeFilter)(nil),
981 (*RowFilter_CellsPerRowOffsetFilter)(nil),
982 (*RowFilter_CellsPerRowLimitFilter)(nil),
983 (*RowFilter_CellsPerColumnLimitFilter)(nil),
984 (*RowFilter_StripValueTransformer)(nil),
985 (*RowFilter_ApplyLabelTransformer)(nil),
989 func _RowFilter_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
990 m := msg.(*RowFilter)
992 switch x := m.Filter.(type) {
993 case *RowFilter_Chain_:
994 b.EncodeVarint(1<<3 | proto.WireBytes)
995 if err := b.EncodeMessage(x.Chain); err != nil {
998 case *RowFilter_Interleave_:
999 b.EncodeVarint(2<<3 | proto.WireBytes)
1000 if err := b.EncodeMessage(x.Interleave); err != nil {
1003 case *RowFilter_Condition_:
1004 b.EncodeVarint(3<<3 | proto.WireBytes)
1005 if err := b.EncodeMessage(x.Condition); err != nil {
1008 case *RowFilter_Sink:
1013 b.EncodeVarint(16<<3 | proto.WireVarint)
1015 case *RowFilter_PassAllFilter:
1017 if x.PassAllFilter {
1020 b.EncodeVarint(17<<3 | proto.WireVarint)
1022 case *RowFilter_BlockAllFilter:
1024 if x.BlockAllFilter {
1027 b.EncodeVarint(18<<3 | proto.WireVarint)
1029 case *RowFilter_RowKeyRegexFilter:
1030 b.EncodeVarint(4<<3 | proto.WireBytes)
1031 b.EncodeRawBytes(x.RowKeyRegexFilter)
1032 case *RowFilter_RowSampleFilter:
1033 b.EncodeVarint(14<<3 | proto.WireFixed64)
1034 b.EncodeFixed64(math.Float64bits(x.RowSampleFilter))
1035 case *RowFilter_FamilyNameRegexFilter:
1036 b.EncodeVarint(5<<3 | proto.WireBytes)
1037 b.EncodeStringBytes(x.FamilyNameRegexFilter)
1038 case *RowFilter_ColumnQualifierRegexFilter:
1039 b.EncodeVarint(6<<3 | proto.WireBytes)
1040 b.EncodeRawBytes(x.ColumnQualifierRegexFilter)
1041 case *RowFilter_ColumnRangeFilter:
1042 b.EncodeVarint(7<<3 | proto.WireBytes)
1043 if err := b.EncodeMessage(x.ColumnRangeFilter); err != nil {
1046 case *RowFilter_TimestampRangeFilter:
1047 b.EncodeVarint(8<<3 | proto.WireBytes)
1048 if err := b.EncodeMessage(x.TimestampRangeFilter); err != nil {
1051 case *RowFilter_ValueRegexFilter:
1052 b.EncodeVarint(9<<3 | proto.WireBytes)
1053 b.EncodeRawBytes(x.ValueRegexFilter)
1054 case *RowFilter_ValueRangeFilter:
1055 b.EncodeVarint(15<<3 | proto.WireBytes)
1056 if err := b.EncodeMessage(x.ValueRangeFilter); err != nil {
1059 case *RowFilter_CellsPerRowOffsetFilter:
1060 b.EncodeVarint(10<<3 | proto.WireVarint)
1061 b.EncodeVarint(uint64(x.CellsPerRowOffsetFilter))
1062 case *RowFilter_CellsPerRowLimitFilter:
1063 b.EncodeVarint(11<<3 | proto.WireVarint)
1064 b.EncodeVarint(uint64(x.CellsPerRowLimitFilter))
1065 case *RowFilter_CellsPerColumnLimitFilter:
1066 b.EncodeVarint(12<<3 | proto.WireVarint)
1067 b.EncodeVarint(uint64(x.CellsPerColumnLimitFilter))
1068 case *RowFilter_StripValueTransformer:
1070 if x.StripValueTransformer {
1073 b.EncodeVarint(13<<3 | proto.WireVarint)
1075 case *RowFilter_ApplyLabelTransformer:
1076 b.EncodeVarint(19<<3 | proto.WireBytes)
1077 b.EncodeStringBytes(x.ApplyLabelTransformer)
1080 return fmt.Errorf("RowFilter.Filter has unexpected type %T", x)
1085 func _RowFilter_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
1086 m := msg.(*RowFilter)
1088 case 1: // filter.chain
1089 if wire != proto.WireBytes {
1090 return true, proto.ErrInternalBadWireType
1092 msg := new(RowFilter_Chain)
1093 err := b.DecodeMessage(msg)
1094 m.Filter = &RowFilter_Chain_{msg}
1096 case 2: // filter.interleave
1097 if wire != proto.WireBytes {
1098 return true, proto.ErrInternalBadWireType
1100 msg := new(RowFilter_Interleave)
1101 err := b.DecodeMessage(msg)
1102 m.Filter = &RowFilter_Interleave_{msg}
1104 case 3: // filter.condition
1105 if wire != proto.WireBytes {
1106 return true, proto.ErrInternalBadWireType
1108 msg := new(RowFilter_Condition)
1109 err := b.DecodeMessage(msg)
1110 m.Filter = &RowFilter_Condition_{msg}
1112 case 16: // filter.sink
1113 if wire != proto.WireVarint {
1114 return true, proto.ErrInternalBadWireType
1116 x, err := b.DecodeVarint()
1117 m.Filter = &RowFilter_Sink{x != 0}
1119 case 17: // filter.pass_all_filter
1120 if wire != proto.WireVarint {
1121 return true, proto.ErrInternalBadWireType
1123 x, err := b.DecodeVarint()
1124 m.Filter = &RowFilter_PassAllFilter{x != 0}
1126 case 18: // filter.block_all_filter
1127 if wire != proto.WireVarint {
1128 return true, proto.ErrInternalBadWireType
1130 x, err := b.DecodeVarint()
1131 m.Filter = &RowFilter_BlockAllFilter{x != 0}
1133 case 4: // filter.row_key_regex_filter
1134 if wire != proto.WireBytes {
1135 return true, proto.ErrInternalBadWireType
1137 x, err := b.DecodeRawBytes(true)
1138 m.Filter = &RowFilter_RowKeyRegexFilter{x}
1140 case 14: // filter.row_sample_filter
1141 if wire != proto.WireFixed64 {
1142 return true, proto.ErrInternalBadWireType
1144 x, err := b.DecodeFixed64()
1145 m.Filter = &RowFilter_RowSampleFilter{math.Float64frombits(x)}
1147 case 5: // filter.family_name_regex_filter
1148 if wire != proto.WireBytes {
1149 return true, proto.ErrInternalBadWireType
1151 x, err := b.DecodeStringBytes()
1152 m.Filter = &RowFilter_FamilyNameRegexFilter{x}
1154 case 6: // filter.column_qualifier_regex_filter
1155 if wire != proto.WireBytes {
1156 return true, proto.ErrInternalBadWireType
1158 x, err := b.DecodeRawBytes(true)
1159 m.Filter = &RowFilter_ColumnQualifierRegexFilter{x}
1161 case 7: // filter.column_range_filter
1162 if wire != proto.WireBytes {
1163 return true, proto.ErrInternalBadWireType
1165 msg := new(ColumnRange)
1166 err := b.DecodeMessage(msg)
1167 m.Filter = &RowFilter_ColumnRangeFilter{msg}
1169 case 8: // filter.timestamp_range_filter
1170 if wire != proto.WireBytes {
1171 return true, proto.ErrInternalBadWireType
1173 msg := new(TimestampRange)
1174 err := b.DecodeMessage(msg)
1175 m.Filter = &RowFilter_TimestampRangeFilter{msg}
1177 case 9: // filter.value_regex_filter
1178 if wire != proto.WireBytes {
1179 return true, proto.ErrInternalBadWireType
1181 x, err := b.DecodeRawBytes(true)
1182 m.Filter = &RowFilter_ValueRegexFilter{x}
1184 case 15: // filter.value_range_filter
1185 if wire != proto.WireBytes {
1186 return true, proto.ErrInternalBadWireType
1188 msg := new(ValueRange)
1189 err := b.DecodeMessage(msg)
1190 m.Filter = &RowFilter_ValueRangeFilter{msg}
1192 case 10: // filter.cells_per_row_offset_filter
1193 if wire != proto.WireVarint {
1194 return true, proto.ErrInternalBadWireType
1196 x, err := b.DecodeVarint()
1197 m.Filter = &RowFilter_CellsPerRowOffsetFilter{int32(x)}
1199 case 11: // filter.cells_per_row_limit_filter
1200 if wire != proto.WireVarint {
1201 return true, proto.ErrInternalBadWireType
1203 x, err := b.DecodeVarint()
1204 m.Filter = &RowFilter_CellsPerRowLimitFilter{int32(x)}
1206 case 12: // filter.cells_per_column_limit_filter
1207 if wire != proto.WireVarint {
1208 return true, proto.ErrInternalBadWireType
1210 x, err := b.DecodeVarint()
1211 m.Filter = &RowFilter_CellsPerColumnLimitFilter{int32(x)}
1213 case 13: // filter.strip_value_transformer
1214 if wire != proto.WireVarint {
1215 return true, proto.ErrInternalBadWireType
1217 x, err := b.DecodeVarint()
1218 m.Filter = &RowFilter_StripValueTransformer{x != 0}
1220 case 19: // filter.apply_label_transformer
1221 if wire != proto.WireBytes {
1222 return true, proto.ErrInternalBadWireType
1224 x, err := b.DecodeStringBytes()
1225 m.Filter = &RowFilter_ApplyLabelTransformer{x}
1232 func _RowFilter_OneofSizer(msg proto.Message) (n int) {
1233 m := msg.(*RowFilter)
1235 switch x := m.Filter.(type) {
1236 case *RowFilter_Chain_:
1237 s := proto.Size(x.Chain)
1238 n += proto.SizeVarint(1<<3 | proto.WireBytes)
1239 n += proto.SizeVarint(uint64(s))
1241 case *RowFilter_Interleave_:
1242 s := proto.Size(x.Interleave)
1243 n += proto.SizeVarint(2<<3 | proto.WireBytes)
1244 n += proto.SizeVarint(uint64(s))
1246 case *RowFilter_Condition_:
1247 s := proto.Size(x.Condition)
1248 n += proto.SizeVarint(3<<3 | proto.WireBytes)
1249 n += proto.SizeVarint(uint64(s))
1251 case *RowFilter_Sink:
1252 n += proto.SizeVarint(16<<3 | proto.WireVarint)
1254 case *RowFilter_PassAllFilter:
1255 n += proto.SizeVarint(17<<3 | proto.WireVarint)
1257 case *RowFilter_BlockAllFilter:
1258 n += proto.SizeVarint(18<<3 | proto.WireVarint)
1260 case *RowFilter_RowKeyRegexFilter:
1261 n += proto.SizeVarint(4<<3 | proto.WireBytes)
1262 n += proto.SizeVarint(uint64(len(x.RowKeyRegexFilter)))
1263 n += len(x.RowKeyRegexFilter)
1264 case *RowFilter_RowSampleFilter:
1265 n += proto.SizeVarint(14<<3 | proto.WireFixed64)
1267 case *RowFilter_FamilyNameRegexFilter:
1268 n += proto.SizeVarint(5<<3 | proto.WireBytes)
1269 n += proto.SizeVarint(uint64(len(x.FamilyNameRegexFilter)))
1270 n += len(x.FamilyNameRegexFilter)
1271 case *RowFilter_ColumnQualifierRegexFilter:
1272 n += proto.SizeVarint(6<<3 | proto.WireBytes)
1273 n += proto.SizeVarint(uint64(len(x.ColumnQualifierRegexFilter)))
1274 n += len(x.ColumnQualifierRegexFilter)
1275 case *RowFilter_ColumnRangeFilter:
1276 s := proto.Size(x.ColumnRangeFilter)
1277 n += proto.SizeVarint(7<<3 | proto.WireBytes)
1278 n += proto.SizeVarint(uint64(s))
1280 case *RowFilter_TimestampRangeFilter:
1281 s := proto.Size(x.TimestampRangeFilter)
1282 n += proto.SizeVarint(8<<3 | proto.WireBytes)
1283 n += proto.SizeVarint(uint64(s))
1285 case *RowFilter_ValueRegexFilter:
1286 n += proto.SizeVarint(9<<3 | proto.WireBytes)
1287 n += proto.SizeVarint(uint64(len(x.ValueRegexFilter)))
1288 n += len(x.ValueRegexFilter)
1289 case *RowFilter_ValueRangeFilter:
1290 s := proto.Size(x.ValueRangeFilter)
1291 n += proto.SizeVarint(15<<3 | proto.WireBytes)
1292 n += proto.SizeVarint(uint64(s))
1294 case *RowFilter_CellsPerRowOffsetFilter:
1295 n += proto.SizeVarint(10<<3 | proto.WireVarint)
1296 n += proto.SizeVarint(uint64(x.CellsPerRowOffsetFilter))
1297 case *RowFilter_CellsPerRowLimitFilter:
1298 n += proto.SizeVarint(11<<3 | proto.WireVarint)
1299 n += proto.SizeVarint(uint64(x.CellsPerRowLimitFilter))
1300 case *RowFilter_CellsPerColumnLimitFilter:
1301 n += proto.SizeVarint(12<<3 | proto.WireVarint)
1302 n += proto.SizeVarint(uint64(x.CellsPerColumnLimitFilter))
1303 case *RowFilter_StripValueTransformer:
1304 n += proto.SizeVarint(13<<3 | proto.WireVarint)
1306 case *RowFilter_ApplyLabelTransformer:
1307 n += proto.SizeVarint(19<<3 | proto.WireBytes)
1308 n += proto.SizeVarint(uint64(len(x.ApplyLabelTransformer)))
1309 n += len(x.ApplyLabelTransformer)
1312 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
1317 // A RowFilter which sends rows through several RowFilters in sequence.
1318 type RowFilter_Chain struct {
1319 // The elements of "filters" are chained together to process the input row:
1320 // in row -> f(0) -> intermediate row -> f(1) -> ... -> f(N) -> out row
1321 // The full chain is executed atomically.
1322 Filters []*RowFilter `protobuf:"bytes,1,rep,name=filters" json:"filters,omitempty"`
1325 func (m *RowFilter_Chain) Reset() { *m = RowFilter_Chain{} }
1326 func (m *RowFilter_Chain) String() string { return proto.CompactTextString(m) }
1327 func (*RowFilter_Chain) ProtoMessage() {}
1328 func (*RowFilter_Chain) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9, 0} }
1330 func (m *RowFilter_Chain) GetFilters() []*RowFilter {
1337 // A RowFilter which sends each row to each of several component
1338 // RowFilters and interleaves the results.
1339 type RowFilter_Interleave struct {
1340 // The elements of "filters" all process a copy of the input row, and the
1341 // results are pooled, sorted, and combined into a single output row.
1342 // If multiple cells are produced with the same column and timestamp,
1343 // they will all appear in the output row in an unspecified mutual order.
1344 // Consider the following example, with three filters:
1348 // -----------------------------------------------------
1352 // 1: foo,bar,10,x foo,bar,10,z far,bar,7,a
1353 // 2: foo,blah,11,z far,blah,5,x far,blah,5,x
1355 // -----------------------------------------------------
1357 // 1: foo,bar,10,z // could have switched with #2
1358 // 2: foo,bar,10,x // could have switched with #1
1361 // 5: far,blah,5,x // identical to #6
1362 // 6: far,blah,5,x // identical to #5
1363 // All interleaved filters are executed atomically.
1364 Filters []*RowFilter `protobuf:"bytes,1,rep,name=filters" json:"filters,omitempty"`
1367 func (m *RowFilter_Interleave) Reset() { *m = RowFilter_Interleave{} }
1368 func (m *RowFilter_Interleave) String() string { return proto.CompactTextString(m) }
1369 func (*RowFilter_Interleave) ProtoMessage() {}
1370 func (*RowFilter_Interleave) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9, 1} }
1372 func (m *RowFilter_Interleave) GetFilters() []*RowFilter {
1379 // A RowFilter which evaluates one of two possible RowFilters, depending on
1380 // whether or not a predicate RowFilter outputs any cells from the input row.
1382 // IMPORTANT NOTE: The predicate filter does not execute atomically with the
1383 // true and false filters, which may lead to inconsistent or unexpected
1384 // results. Additionally, Condition filters have poor performance, especially
1385 // when filters are set for the false condition.
1386 type RowFilter_Condition struct {
1387 // If "predicate_filter" outputs any cells, then "true_filter" will be
1388 // evaluated on the input row. Otherwise, "false_filter" will be evaluated.
1389 PredicateFilter *RowFilter `protobuf:"bytes,1,opt,name=predicate_filter,json=predicateFilter" json:"predicate_filter,omitempty"`
1390 // The filter to apply to the input row if "predicate_filter" returns any
1391 // results. If not provided, no results will be returned in the true case.
1392 TrueFilter *RowFilter `protobuf:"bytes,2,opt,name=true_filter,json=trueFilter" json:"true_filter,omitempty"`
1393 // The filter to apply to the input row if "predicate_filter" does not
1394 // return any results. If not provided, no results will be returned in the
1396 FalseFilter *RowFilter `protobuf:"bytes,3,opt,name=false_filter,json=falseFilter" json:"false_filter,omitempty"`
1399 func (m *RowFilter_Condition) Reset() { *m = RowFilter_Condition{} }
1400 func (m *RowFilter_Condition) String() string { return proto.CompactTextString(m) }
1401 func (*RowFilter_Condition) ProtoMessage() {}
1402 func (*RowFilter_Condition) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9, 2} }
1404 func (m *RowFilter_Condition) GetPredicateFilter() *RowFilter {
1406 return m.PredicateFilter
1411 func (m *RowFilter_Condition) GetTrueFilter() *RowFilter {
1418 func (m *RowFilter_Condition) GetFalseFilter() *RowFilter {
1420 return m.FalseFilter
1425 // Specifies a particular change to be made to the contents of a row.
1426 type Mutation struct {
1427 // Which of the possible Mutation types to apply.
1429 // Types that are valid to be assigned to Mutation:
1430 // *Mutation_SetCell_
1431 // *Mutation_DeleteFromColumn_
1432 // *Mutation_DeleteFromFamily_
1433 // *Mutation_DeleteFromRow_
1434 Mutation isMutation_Mutation `protobuf_oneof:"mutation"`
1437 func (m *Mutation) Reset() { *m = Mutation{} }
1438 func (m *Mutation) String() string { return proto.CompactTextString(m) }
1439 func (*Mutation) ProtoMessage() {}
1440 func (*Mutation) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
1442 type isMutation_Mutation interface {
1443 isMutation_Mutation()
1446 type Mutation_SetCell_ struct {
1447 SetCell *Mutation_SetCell `protobuf:"bytes,1,opt,name=set_cell,json=setCell,oneof"`
1449 type Mutation_DeleteFromColumn_ struct {
1450 DeleteFromColumn *Mutation_DeleteFromColumn `protobuf:"bytes,2,opt,name=delete_from_column,json=deleteFromColumn,oneof"`
1452 type Mutation_DeleteFromFamily_ struct {
1453 DeleteFromFamily *Mutation_DeleteFromFamily `protobuf:"bytes,3,opt,name=delete_from_family,json=deleteFromFamily,oneof"`
1455 type Mutation_DeleteFromRow_ struct {
1456 DeleteFromRow *Mutation_DeleteFromRow `protobuf:"bytes,4,opt,name=delete_from_row,json=deleteFromRow,oneof"`
1459 func (*Mutation_SetCell_) isMutation_Mutation() {}
1460 func (*Mutation_DeleteFromColumn_) isMutation_Mutation() {}
1461 func (*Mutation_DeleteFromFamily_) isMutation_Mutation() {}
1462 func (*Mutation_DeleteFromRow_) isMutation_Mutation() {}
1464 func (m *Mutation) GetMutation() isMutation_Mutation {
1471 func (m *Mutation) GetSetCell() *Mutation_SetCell {
1472 if x, ok := m.GetMutation().(*Mutation_SetCell_); ok {
1478 func (m *Mutation) GetDeleteFromColumn() *Mutation_DeleteFromColumn {
1479 if x, ok := m.GetMutation().(*Mutation_DeleteFromColumn_); ok {
1480 return x.DeleteFromColumn
1485 func (m *Mutation) GetDeleteFromFamily() *Mutation_DeleteFromFamily {
1486 if x, ok := m.GetMutation().(*Mutation_DeleteFromFamily_); ok {
1487 return x.DeleteFromFamily
1492 func (m *Mutation) GetDeleteFromRow() *Mutation_DeleteFromRow {
1493 if x, ok := m.GetMutation().(*Mutation_DeleteFromRow_); ok {
1494 return x.DeleteFromRow
1499 // XXX_OneofFuncs is for the internal use of the proto package.
1500 func (*Mutation) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
1501 return _Mutation_OneofMarshaler, _Mutation_OneofUnmarshaler, _Mutation_OneofSizer, []interface{}{
1502 (*Mutation_SetCell_)(nil),
1503 (*Mutation_DeleteFromColumn_)(nil),
1504 (*Mutation_DeleteFromFamily_)(nil),
1505 (*Mutation_DeleteFromRow_)(nil),
1509 func _Mutation_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
1510 m := msg.(*Mutation)
1512 switch x := m.Mutation.(type) {
1513 case *Mutation_SetCell_:
1514 b.EncodeVarint(1<<3 | proto.WireBytes)
1515 if err := b.EncodeMessage(x.SetCell); err != nil {
1518 case *Mutation_DeleteFromColumn_:
1519 b.EncodeVarint(2<<3 | proto.WireBytes)
1520 if err := b.EncodeMessage(x.DeleteFromColumn); err != nil {
1523 case *Mutation_DeleteFromFamily_:
1524 b.EncodeVarint(3<<3 | proto.WireBytes)
1525 if err := b.EncodeMessage(x.DeleteFromFamily); err != nil {
1528 case *Mutation_DeleteFromRow_:
1529 b.EncodeVarint(4<<3 | proto.WireBytes)
1530 if err := b.EncodeMessage(x.DeleteFromRow); err != nil {
1535 return fmt.Errorf("Mutation.Mutation has unexpected type %T", x)
1540 func _Mutation_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
1541 m := msg.(*Mutation)
1543 case 1: // mutation.set_cell
1544 if wire != proto.WireBytes {
1545 return true, proto.ErrInternalBadWireType
1547 msg := new(Mutation_SetCell)
1548 err := b.DecodeMessage(msg)
1549 m.Mutation = &Mutation_SetCell_{msg}
1551 case 2: // mutation.delete_from_column
1552 if wire != proto.WireBytes {
1553 return true, proto.ErrInternalBadWireType
1555 msg := new(Mutation_DeleteFromColumn)
1556 err := b.DecodeMessage(msg)
1557 m.Mutation = &Mutation_DeleteFromColumn_{msg}
1559 case 3: // mutation.delete_from_family
1560 if wire != proto.WireBytes {
1561 return true, proto.ErrInternalBadWireType
1563 msg := new(Mutation_DeleteFromFamily)
1564 err := b.DecodeMessage(msg)
1565 m.Mutation = &Mutation_DeleteFromFamily_{msg}
1567 case 4: // mutation.delete_from_row
1568 if wire != proto.WireBytes {
1569 return true, proto.ErrInternalBadWireType
1571 msg := new(Mutation_DeleteFromRow)
1572 err := b.DecodeMessage(msg)
1573 m.Mutation = &Mutation_DeleteFromRow_{msg}
1580 func _Mutation_OneofSizer(msg proto.Message) (n int) {
1581 m := msg.(*Mutation)
1583 switch x := m.Mutation.(type) {
1584 case *Mutation_SetCell_:
1585 s := proto.Size(x.SetCell)
1586 n += proto.SizeVarint(1<<3 | proto.WireBytes)
1587 n += proto.SizeVarint(uint64(s))
1589 case *Mutation_DeleteFromColumn_:
1590 s := proto.Size(x.DeleteFromColumn)
1591 n += proto.SizeVarint(2<<3 | proto.WireBytes)
1592 n += proto.SizeVarint(uint64(s))
1594 case *Mutation_DeleteFromFamily_:
1595 s := proto.Size(x.DeleteFromFamily)
1596 n += proto.SizeVarint(3<<3 | proto.WireBytes)
1597 n += proto.SizeVarint(uint64(s))
1599 case *Mutation_DeleteFromRow_:
1600 s := proto.Size(x.DeleteFromRow)
1601 n += proto.SizeVarint(4<<3 | proto.WireBytes)
1602 n += proto.SizeVarint(uint64(s))
1606 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
1611 // A Mutation which sets the value of the specified cell.
1612 type Mutation_SetCell struct {
1613 // The name of the family into which new data should be written.
1614 // Must match [-_.a-zA-Z0-9]+
1615 FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName" json:"family_name,omitempty"`
1616 // The qualifier of the column into which new data should be written.
1617 // Can be any byte string, including the empty string.
1618 ColumnQualifier []byte `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier,proto3" json:"column_qualifier,omitempty"`
1619 // The timestamp of the cell into which new data should be written.
1620 // Use -1 for current Bigtable server time.
1621 // Otherwise, the client should set this value itself, noting that the
1622 // default value is a timestamp of zero if the field is left unspecified.
1623 // Values must match the "granularity" of the table (e.g. micros, millis).
1624 TimestampMicros int64 `protobuf:"varint,3,opt,name=timestamp_micros,json=timestampMicros" json:"timestamp_micros,omitempty"`
1625 // The value to be written into the specified cell.
1626 Value []byte `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"`
1629 func (m *Mutation_SetCell) Reset() { *m = Mutation_SetCell{} }
1630 func (m *Mutation_SetCell) String() string { return proto.CompactTextString(m) }
1631 func (*Mutation_SetCell) ProtoMessage() {}
1632 func (*Mutation_SetCell) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10, 0} }
1634 func (m *Mutation_SetCell) GetFamilyName() string {
1641 func (m *Mutation_SetCell) GetColumnQualifier() []byte {
1643 return m.ColumnQualifier
1648 func (m *Mutation_SetCell) GetTimestampMicros() int64 {
1650 return m.TimestampMicros
1655 func (m *Mutation_SetCell) GetValue() []byte {
1662 // A Mutation which deletes cells from the specified column, optionally
1663 // restricting the deletions to a given timestamp range.
1664 type Mutation_DeleteFromColumn struct {
1665 // The name of the family from which cells should be deleted.
1666 // Must match [-_.a-zA-Z0-9]+
1667 FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName" json:"family_name,omitempty"`
1668 // The qualifier of the column from which cells should be deleted.
1669 // Can be any byte string, including the empty string.
1670 ColumnQualifier []byte `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier,proto3" json:"column_qualifier,omitempty"`
1671 // The range of timestamps within which cells should be deleted.
1672 TimeRange *TimestampRange `protobuf:"bytes,3,opt,name=time_range,json=timeRange" json:"time_range,omitempty"`
1675 func (m *Mutation_DeleteFromColumn) Reset() { *m = Mutation_DeleteFromColumn{} }
1676 func (m *Mutation_DeleteFromColumn) String() string { return proto.CompactTextString(m) }
1677 func (*Mutation_DeleteFromColumn) ProtoMessage() {}
1678 func (*Mutation_DeleteFromColumn) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10, 1} }
1680 func (m *Mutation_DeleteFromColumn) GetFamilyName() string {
1687 func (m *Mutation_DeleteFromColumn) GetColumnQualifier() []byte {
1689 return m.ColumnQualifier
1694 func (m *Mutation_DeleteFromColumn) GetTimeRange() *TimestampRange {
1701 // A Mutation which deletes all cells from the specified column family.
1702 type Mutation_DeleteFromFamily struct {
1703 // The name of the family from which cells should be deleted.
1704 // Must match [-_.a-zA-Z0-9]+
1705 FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName" json:"family_name,omitempty"`
1708 func (m *Mutation_DeleteFromFamily) Reset() { *m = Mutation_DeleteFromFamily{} }
1709 func (m *Mutation_DeleteFromFamily) String() string { return proto.CompactTextString(m) }
1710 func (*Mutation_DeleteFromFamily) ProtoMessage() {}
1711 func (*Mutation_DeleteFromFamily) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10, 2} }
1713 func (m *Mutation_DeleteFromFamily) GetFamilyName() string {
1720 // A Mutation which deletes all cells from the containing row.
1721 type Mutation_DeleteFromRow struct {
1724 func (m *Mutation_DeleteFromRow) Reset() { *m = Mutation_DeleteFromRow{} }
1725 func (m *Mutation_DeleteFromRow) String() string { return proto.CompactTextString(m) }
1726 func (*Mutation_DeleteFromRow) ProtoMessage() {}
1727 func (*Mutation_DeleteFromRow) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10, 3} }
1729 // Specifies an atomic read/modify/write operation on the latest value of the
1730 // specified column.
1731 type ReadModifyWriteRule struct {
1732 // The name of the family to which the read/modify/write should be applied.
1733 // Must match [-_.a-zA-Z0-9]+
1734 FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName" json:"family_name,omitempty"`
1735 // The qualifier of the column to which the read/modify/write should be
1737 // Can be any byte string, including the empty string.
1738 ColumnQualifier []byte `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier,proto3" json:"column_qualifier,omitempty"`
1739 // The rule used to determine the column's new latest value from its current
1742 // Types that are valid to be assigned to Rule:
1743 // *ReadModifyWriteRule_AppendValue
1744 // *ReadModifyWriteRule_IncrementAmount
1745 Rule isReadModifyWriteRule_Rule `protobuf_oneof:"rule"`
1748 func (m *ReadModifyWriteRule) Reset() { *m = ReadModifyWriteRule{} }
1749 func (m *ReadModifyWriteRule) String() string { return proto.CompactTextString(m) }
1750 func (*ReadModifyWriteRule) ProtoMessage() {}
1751 func (*ReadModifyWriteRule) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
1753 type isReadModifyWriteRule_Rule interface {
1754 isReadModifyWriteRule_Rule()
1757 type ReadModifyWriteRule_AppendValue struct {
1758 AppendValue []byte `protobuf:"bytes,3,opt,name=append_value,json=appendValue,proto3,oneof"`
1760 type ReadModifyWriteRule_IncrementAmount struct {
1761 IncrementAmount int64 `protobuf:"varint,4,opt,name=increment_amount,json=incrementAmount,oneof"`
1764 func (*ReadModifyWriteRule_AppendValue) isReadModifyWriteRule_Rule() {}
1765 func (*ReadModifyWriteRule_IncrementAmount) isReadModifyWriteRule_Rule() {}
1767 func (m *ReadModifyWriteRule) GetRule() isReadModifyWriteRule_Rule {
1774 func (m *ReadModifyWriteRule) GetFamilyName() string {
1781 func (m *ReadModifyWriteRule) GetColumnQualifier() []byte {
1783 return m.ColumnQualifier
1788 func (m *ReadModifyWriteRule) GetAppendValue() []byte {
1789 if x, ok := m.GetRule().(*ReadModifyWriteRule_AppendValue); ok {
1790 return x.AppendValue
1795 func (m *ReadModifyWriteRule) GetIncrementAmount() int64 {
1796 if x, ok := m.GetRule().(*ReadModifyWriteRule_IncrementAmount); ok {
1797 return x.IncrementAmount
1802 // XXX_OneofFuncs is for the internal use of the proto package.
1803 func (*ReadModifyWriteRule) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
1804 return _ReadModifyWriteRule_OneofMarshaler, _ReadModifyWriteRule_OneofUnmarshaler, _ReadModifyWriteRule_OneofSizer, []interface{}{
1805 (*ReadModifyWriteRule_AppendValue)(nil),
1806 (*ReadModifyWriteRule_IncrementAmount)(nil),
1810 func _ReadModifyWriteRule_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
1811 m := msg.(*ReadModifyWriteRule)
1813 switch x := m.Rule.(type) {
1814 case *ReadModifyWriteRule_AppendValue:
1815 b.EncodeVarint(3<<3 | proto.WireBytes)
1816 b.EncodeRawBytes(x.AppendValue)
1817 case *ReadModifyWriteRule_IncrementAmount:
1818 b.EncodeVarint(4<<3 | proto.WireVarint)
1819 b.EncodeVarint(uint64(x.IncrementAmount))
1822 return fmt.Errorf("ReadModifyWriteRule.Rule has unexpected type %T", x)
1827 func _ReadModifyWriteRule_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
1828 m := msg.(*ReadModifyWriteRule)
1830 case 3: // rule.append_value
1831 if wire != proto.WireBytes {
1832 return true, proto.ErrInternalBadWireType
1834 x, err := b.DecodeRawBytes(true)
1835 m.Rule = &ReadModifyWriteRule_AppendValue{x}
1837 case 4: // rule.increment_amount
1838 if wire != proto.WireVarint {
1839 return true, proto.ErrInternalBadWireType
1841 x, err := b.DecodeVarint()
1842 m.Rule = &ReadModifyWriteRule_IncrementAmount{int64(x)}
1849 func _ReadModifyWriteRule_OneofSizer(msg proto.Message) (n int) {
1850 m := msg.(*ReadModifyWriteRule)
1852 switch x := m.Rule.(type) {
1853 case *ReadModifyWriteRule_AppendValue:
1854 n += proto.SizeVarint(3<<3 | proto.WireBytes)
1855 n += proto.SizeVarint(uint64(len(x.AppendValue)))
1856 n += len(x.AppendValue)
1857 case *ReadModifyWriteRule_IncrementAmount:
1858 n += proto.SizeVarint(4<<3 | proto.WireVarint)
1859 n += proto.SizeVarint(uint64(x.IncrementAmount))
1862 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
1868 proto.RegisterType((*Row)(nil), "google.bigtable.v1.Row")
1869 proto.RegisterType((*Family)(nil), "google.bigtable.v1.Family")
1870 proto.RegisterType((*Column)(nil), "google.bigtable.v1.Column")
1871 proto.RegisterType((*Cell)(nil), "google.bigtable.v1.Cell")
1872 proto.RegisterType((*RowRange)(nil), "google.bigtable.v1.RowRange")
1873 proto.RegisterType((*RowSet)(nil), "google.bigtable.v1.RowSet")
1874 proto.RegisterType((*ColumnRange)(nil), "google.bigtable.v1.ColumnRange")
1875 proto.RegisterType((*TimestampRange)(nil), "google.bigtable.v1.TimestampRange")
1876 proto.RegisterType((*ValueRange)(nil), "google.bigtable.v1.ValueRange")
1877 proto.RegisterType((*RowFilter)(nil), "google.bigtable.v1.RowFilter")
1878 proto.RegisterType((*RowFilter_Chain)(nil), "google.bigtable.v1.RowFilter.Chain")
1879 proto.RegisterType((*RowFilter_Interleave)(nil), "google.bigtable.v1.RowFilter.Interleave")
1880 proto.RegisterType((*RowFilter_Condition)(nil), "google.bigtable.v1.RowFilter.Condition")
1881 proto.RegisterType((*Mutation)(nil), "google.bigtable.v1.Mutation")
1882 proto.RegisterType((*Mutation_SetCell)(nil), "google.bigtable.v1.Mutation.SetCell")
1883 proto.RegisterType((*Mutation_DeleteFromColumn)(nil), "google.bigtable.v1.Mutation.DeleteFromColumn")
1884 proto.RegisterType((*Mutation_DeleteFromFamily)(nil), "google.bigtable.v1.Mutation.DeleteFromFamily")
1885 proto.RegisterType((*Mutation_DeleteFromRow)(nil), "google.bigtable.v1.Mutation.DeleteFromRow")
1886 proto.RegisterType((*ReadModifyWriteRule)(nil), "google.bigtable.v1.ReadModifyWriteRule")
1889 func init() { proto.RegisterFile("google/bigtable/v1/bigtable_data.proto", fileDescriptor0) }
1891 var fileDescriptor0 = []byte{
1892 // 1378 bytes of a gzipped FileDescriptorProto
1893 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xdb, 0x6e, 0x1b, 0x37,
1894 0x13, 0xd6, 0x5a, 0xb2, 0x0e, 0xb3, 0x76, 0x24, 0xd3, 0x27, 0x45, 0x49, 0xfe, 0x18, 0xca, 0x8f,
1895 0x56, 0x49, 0x5b, 0x39, 0x71, 0x82, 0x36, 0x6d, 0x82, 0x22, 0x56, 0x0e, 0x55, 0x9a, 0x33, 0x63,
1896 0xa4, 0x40, 0x80, 0x62, 0x4b, 0x6b, 0x29, 0x75, 0x11, 0xee, 0x52, 0xe5, 0xae, 0xac, 0xe8, 0x45,
1897 0x7a, 0xdf, 0xe7, 0xe8, 0x5d, 0x5f, 0xa2, 0xaf, 0xd1, 0xcb, 0x5e, 0xf4, 0xa2, 0xe0, 0x61, 0x4f,
1898 0xb2, 0x62, 0x1b, 0x45, 0xee, 0x96, 0x9c, 0xef, 0xfb, 0x66, 0x38, 0x1c, 0x0e, 0xb9, 0xf0, 0xc9,
1899 0x88, 0xf3, 0x11, 0xa3, 0xbb, 0x87, 0xde, 0x28, 0x22, 0x87, 0x8c, 0xee, 0x1e, 0xdd, 0x48, 0xbe,
1900 0x1d, 0x97, 0x44, 0xa4, 0x3b, 0x16, 0x3c, 0xe2, 0x08, 0x69, 0x5c, 0x37, 0xb6, 0x75, 0x8f, 0x6e,
1901 0xb4, 0x5f, 0x40, 0x11, 0xf3, 0x29, 0x6a, 0x40, 0xf1, 0x1d, 0x9d, 0x35, 0xad, 0x1d, 0xab, 0xb3,
1902 0x82, 0xe5, 0x27, 0xfa, 0x12, 0xaa, 0x43, 0xe2, 0x7b, 0xcc, 0xa3, 0x61, 0x73, 0x69, 0xa7, 0xd8,
1903 0xb1, 0xf7, 0x5a, 0xdd, 0xe3, 0xfc, 0xee, 0x23, 0x89, 0x99, 0xe1, 0x04, 0xdb, 0xc6, 0x50, 0xd6,
1904 0x73, 0x08, 0x41, 0x29, 0x20, 0x3e, 0x55, 0xa2, 0x35, 0xac, 0xbe, 0xd1, 0x2d, 0xa8, 0x0c, 0x38,
1905 0x9b, 0xf8, 0xc1, 0x89, 0xa2, 0xf7, 0x15, 0x04, 0xc7, 0xd0, 0xf6, 0x1b, 0x28, 0xeb, 0x29, 0x74,
1906 0x11, 0x6a, 0xbf, 0x4c, 0x08, 0xf3, 0x86, 0x1e, 0x15, 0x26, 0xda, 0x74, 0x02, 0x75, 0x61, 0x79,
1907 0x40, 0x19, 0x8b, 0xb5, 0x9b, 0x0b, 0xb5, 0x29, 0x63, 0x58, 0xc3, 0xda, 0x0e, 0x94, 0xe4, 0x10,
1908 0x5d, 0x85, 0x46, 0xe4, 0xf9, 0x34, 0x8c, 0x88, 0x3f, 0x76, 0x7c, 0x6f, 0x20, 0x78, 0xa8, 0xc4,
1909 0x8b, 0xb8, 0x9e, 0xcc, 0x3f, 0x53, 0xd3, 0x68, 0x03, 0x96, 0x8f, 0x08, 0x9b, 0xd0, 0xe6, 0x92,
1910 0x72, 0xae, 0x07, 0x68, 0x0b, 0xca, 0x8c, 0x1c, 0x52, 0x16, 0x36, 0x8b, 0x3b, 0xc5, 0x4e, 0x0d,
1911 0x9b, 0x51, 0xfb, 0x1e, 0x54, 0x31, 0x9f, 0x62, 0x12, 0x8c, 0x28, 0xba, 0x00, 0xb5, 0x30, 0x22,
1912 0x22, 0x72, 0x64, 0xa2, 0x35, 0xbb, 0xaa, 0x26, 0x9e, 0xd0, 0x19, 0xda, 0x86, 0x0a, 0x0d, 0x5c,
1913 0x65, 0x2a, 0x2a, 0x53, 0x99, 0x06, 0xee, 0x13, 0x3a, 0x6b, 0xff, 0x04, 0x65, 0xcc, 0xa7, 0xaf,
1914 0x69, 0x84, 0xce, 0x43, 0x55, 0xf0, 0xa9, 0x84, 0xc8, 0xe0, 0x8a, 0x9d, 0x15, 0x5c, 0x11, 0x7c,
1915 0xfa, 0x84, 0xce, 0x42, 0x74, 0x07, 0x40, 0x9a, 0x84, 0xf4, 0x13, 0x2f, 0xfe, 0xe2, 0xa2, 0xc5,
1916 0xc7, 0xc1, 0xe0, 0x9a, 0x30, 0x5f, 0x61, 0xfb, 0x8f, 0x25, 0xb0, 0x4d, 0xc2, 0x55, 0x9c, 0x97,
1917 0xc1, 0x56, 0x9b, 0x39, 0x73, 0x32, 0xbb, 0x07, 0x7a, 0xea, 0xb9, 0xdc, 0xc3, 0xbb, 0x70, 0x5e,
1918 0x2f, 0x24, 0x49, 0xbc, 0xe3, 0x05, 0x03, 0x36, 0x09, 0xbd, 0x23, 0x93, 0x96, 0x7e, 0x01, 0x6f,
1919 0x2b, 0xc8, 0xab, 0x18, 0xf1, 0x38, 0x06, 0x2c, 0x62, 0xd3, 0xf7, 0x31, 0xbb, 0xb8, 0x98, 0xfd,
1920 0x30, 0x06, 0xa0, 0xdb, 0xb0, 0x2d, 0xf3, 0xb4, 0xc8, 0x73, 0x49, 0x71, 0x2d, 0xbc, 0x49, 0x03,
1921 0x77, 0x81, 0xdf, 0x63, 0xcc, 0xd4, 0xeb, 0xf2, 0x22, 0x66, 0xe2, 0xb3, 0xb7, 0x06, 0xf5, 0xb9,
1922 0x88, 0x7b, 0x75, 0x58, 0xcd, 0x89, 0xb5, 0xdf, 0xc3, 0xb9, 0x83, 0xb8, 0x52, 0x74, 0x1a, 0x6f,
1923 0xc1, 0x96, 0x66, 0x7d, 0xa0, 0xb2, 0x36, 0x94, 0xf5, 0x60, 0xae, 0xbc, 0xae, 0xc3, 0x86, 0x14,
1924 0x3e, 0xc6, 0x59, 0x52, 0x1c, 0x44, 0x03, 0x77, 0x8e, 0xd1, 0xfe, 0xdb, 0x02, 0x78, 0x23, 0x8b,
1925 0x30, 0x76, 0xbb, 0xa9, 0xdd, 0xaa, 0xc2, 0xcc, 0xa4, 0xc7, 0x32, 0xa9, 0x5d, 0x57, 0x66, 0xc5,
1926 0x48, 0x93, 0x33, 0xc7, 0x4a, 0x53, 0xb3, 0x74, 0x9c, 0x95, 0x6e, 0xc6, 0x75, 0x58, 0x97, 0xc1,
1927 0xce, 0x7b, 0x2a, 0x9a, 0x74, 0xae, 0xd1, 0xc0, 0x9d, 0xf3, 0x93, 0x63, 0xa4, 0x5e, 0x4a, 0xf3,
1928 0x8c, 0x34, 0xf9, 0xab, 0x60, 0x67, 0x22, 0xeb, 0xd9, 0x50, 0x4b, 0x04, 0xda, 0xff, 0xd8, 0x50,
1929 0xc3, 0x7c, 0xfa, 0xc8, 0x63, 0x11, 0x15, 0xe8, 0x0e, 0x2c, 0x0f, 0x7e, 0x26, 0x5e, 0xa0, 0x56,
1930 0x6a, 0xef, 0x5d, 0xf9, 0x40, 0xfd, 0x6b, 0x74, 0xf7, 0xbe, 0x84, 0xf6, 0x0b, 0x58, 0x73, 0xd0,
1931 0xf7, 0x00, 0x5e, 0x10, 0x51, 0xc1, 0x28, 0x31, 0xab, 0xb6, 0xf7, 0x3a, 0x27, 0x2b, 0x3c, 0x4e,
1932 0xf0, 0xfd, 0x02, 0xce, 0xb0, 0xd1, 0x77, 0x50, 0x1b, 0xf0, 0xc0, 0xf5, 0x22, 0x8f, 0x07, 0x2a,
1933 0x19, 0xf6, 0xde, 0xa7, 0xa7, 0x04, 0x13, 0xc3, 0xfb, 0x05, 0x9c, 0x72, 0xd1, 0x06, 0x94, 0x42,
1934 0x2f, 0x78, 0xd7, 0x6c, 0xec, 0x58, 0x9d, 0x6a, 0xbf, 0x80, 0xd5, 0x08, 0x75, 0xa0, 0x3e, 0x26,
1935 0x61, 0xe8, 0x10, 0xc6, 0x9c, 0xa1, 0xe2, 0x37, 0xd7, 0x0c, 0x60, 0x55, 0x1a, 0xf6, 0x19, 0x33,
1936 0x19, 0xb9, 0x06, 0x8d, 0x43, 0xc6, 0x07, 0xef, 0xb2, 0x50, 0x64, 0xa0, 0xe7, 0x94, 0x25, 0xc5,
1937 0xde, 0x80, 0x0d, 0xd3, 0x5d, 0x1c, 0x41, 0x47, 0xf4, 0x7d, 0x8c, 0x2f, 0x99, 0x02, 0x58, 0xd3,
1938 0xbd, 0x06, 0x4b, 0x9b, 0xa1, 0x7c, 0x0e, 0x72, 0xd2, 0x09, 0x89, 0x3f, 0x66, 0x34, 0xc6, 0x9f,
1939 0xdb, 0xb1, 0x3a, 0x56, 0xbf, 0x80, 0xeb, 0x82, 0x4f, 0x5f, 0x2b, 0x8b, 0x41, 0x7f, 0x0d, 0xcd,
1940 0x4c, 0x5b, 0xc9, 0x3b, 0x91, 0x07, 0xb0, 0xd6, 0x2f, 0xe0, 0xcd, 0xb4, 0xcb, 0x64, 0x1d, 0xdd,
1941 0x87, 0x4b, 0xfa, 0x26, 0xc8, 0x9c, 0xde, 0x1c, 0xbf, 0x6c, 0x82, 0x6c, 0x69, 0x58, 0x72, 0x86,
1942 0xb3, 0x22, 0xaf, 0x60, 0xdd, 0x88, 0xa8, 0x36, 0x19, 0x53, 0x2b, 0x6a, 0x7f, 0x2e, 0x9f, 0x70,
1943 0x0b, 0x49, 0xb4, 0x4c, 0xc0, 0x20, 0x1d, 0x1a, 0xc9, 0xb7, 0xb0, 0x95, 0x1e, 0xd4, 0x9c, 0x6a,
1944 0x55, 0xa9, 0xb6, 0x17, 0xa9, 0xe6, 0xdb, 0x44, 0xbf, 0x80, 0x37, 0xa2, 0xdc, 0x8c, 0xd1, 0xee,
1945 0x02, 0xd2, 0xa7, 0x24, 0xb7, 0xd0, 0x9a, 0x59, 0x68, 0x43, 0xd9, 0xb2, 0xcb, 0x7b, 0x9e, 0xe0,
1946 0xb3, 0x71, 0xd4, 0x55, 0x1c, 0xff, 0x5b, 0x14, 0x47, 0xda, 0x33, 0x52, 0xbd, 0x8c, 0xff, 0x6f,
1947 0xe1, 0x82, 0xba, 0x23, 0x9d, 0xb1, 0x4c, 0x36, 0x9f, 0x3a, 0x7c, 0x38, 0x0c, 0x69, 0x14, 0x0b,
1948 0xc3, 0x8e, 0xd5, 0x59, 0x96, 0x8d, 0x5a, 0x81, 0x5e, 0x52, 0x81, 0xf9, 0xf4, 0x85, 0x42, 0x18,
1949 0xfe, 0x5d, 0x68, 0xe5, 0xf9, 0xcc, 0xf3, 0xbd, 0x84, 0x6e, 0x1b, 0xfa, 0x56, 0x86, 0xfe, 0x54,
1950 0x02, 0x0c, 0xbb, 0x07, 0x97, 0x52, 0xb6, 0xd9, 0xb6, 0x9c, 0xc0, 0x8a, 0x11, 0x38, 0x1f, 0x0b,
1951 0xe8, 0xcd, 0xca, 0x6a, 0xdc, 0x86, 0xed, 0x30, 0x12, 0xde, 0xd8, 0x74, 0x9b, 0x48, 0x90, 0x20,
1952 0x1c, 0x72, 0xe1, 0x53, 0xd1, 0x5c, 0x35, 0x87, 0x60, 0x53, 0x01, 0x54, 0x26, 0x0e, 0x52, 0xb3,
1953 0x64, 0x92, 0xf1, 0x98, 0xcd, 0x1c, 0x75, 0x8b, 0xe7, 0x98, 0xeb, 0x71, 0xa5, 0x2a, 0xc0, 0x53,
1954 0x69, 0xcf, 0x30, 0x5b, 0xf7, 0x60, 0x59, 0x35, 0x16, 0xf4, 0x15, 0x54, 0x74, 0xa4, 0xfa, 0xae,
1955 0xb6, 0xf7, 0x2e, 0x9d, 0xd8, 0x01, 0x70, 0x8c, 0x6e, 0x3d, 0x04, 0x48, 0x1b, 0xcb, 0x7f, 0x97,
1956 0xf9, 0xd3, 0x82, 0x5a, 0xd2, 0x55, 0x50, 0x1f, 0x1a, 0x63, 0x41, 0x5d, 0x6f, 0x40, 0xa2, 0xa4,
1957 0x34, 0x74, 0x97, 0x3c, 0x45, 0xaf, 0x9e, 0xd0, 0x92, 0xb2, 0xb0, 0x23, 0x31, 0x49, 0x44, 0x96,
1958 0xce, 0x22, 0x02, 0x92, 0x61, 0xf8, 0xf7, 0x60, 0x65, 0x48, 0x58, 0x98, 0x08, 0x14, 0xcf, 0x22,
1959 0x60, 0x2b, 0x8a, 0x1e, 0xf4, 0xaa, 0x50, 0xd6, 0xdc, 0xf6, 0x5f, 0xcb, 0x50, 0x7d, 0x36, 0x89,
1960 0x88, 0x5a, 0xe2, 0x3e, 0x54, 0x65, 0x79, 0xca, 0x72, 0x30, 0x4b, 0xfb, 0xff, 0x22, 0xd1, 0x18,
1961 0xdf, 0x7d, 0x4d, 0x23, 0xf9, 0xf4, 0xeb, 0x17, 0x70, 0x25, 0xd4, 0x9f, 0xe8, 0x47, 0x40, 0x2e,
1962 0x65, 0x54, 0xa6, 0x48, 0x70, 0xdf, 0x94, 0x9d, 0x59, 0xe2, 0x17, 0x27, 0x8a, 0x3d, 0x50, 0xb4,
1963 0x47, 0x82, 0xfb, 0xba, 0x0c, 0xe5, 0x89, 0x72, 0xe7, 0xe6, 0xe6, 0xe5, 0x75, 0xab, 0x33, 0x09,
1964 0x38, 0xab, 0xbc, 0x7e, 0x59, 0xe7, 0xe5, 0xcd, 0x6b, 0xfb, 0x00, 0xea, 0x59, 0x79, 0xc1, 0xa7,
1965 0xaa, 0x77, 0xdb, 0x7b, 0xd7, 0xce, 0xa8, 0x8d, 0xf9, 0x54, 0x5e, 0x21, 0x6e, 0x76, 0xa2, 0xf5,
1966 0xab, 0x05, 0x15, 0x93, 0xaa, 0xd3, 0x1f, 0x86, 0x57, 0xa1, 0x31, 0xdf, 0xa7, 0xcd, 0x43, 0xb7,
1967 0x3e, 0xd7, 0x98, 0x17, 0xbe, 0xb8, 0x8b, 0xa7, 0xbc, 0xb8, 0x4b, 0x99, 0x17, 0x77, 0xeb, 0x37,
1968 0x0b, 0x1a, 0xf3, 0x69, 0xff, 0xa8, 0x11, 0xee, 0x03, 0xc8, 0x48, 0x74, 0x3f, 0x35, 0xdb, 0x74,
1969 0x86, 0x86, 0x8e, 0x6b, 0x92, 0xa5, 0x3e, 0x5b, 0x37, 0xb3, 0x21, 0x9a, 0x6d, 0x3a, 0x2d, 0xc4,
1970 0x56, 0x1d, 0x56, 0x73, 0x7b, 0xd2, 0x03, 0xa8, 0xfa, 0x66, 0xb7, 0xda, 0xbf, 0x5b, 0xb0, 0x8e,
1971 0x29, 0x71, 0x9f, 0x71, 0xd7, 0x1b, 0xce, 0x7e, 0x10, 0x5e, 0x44, 0xf1, 0x84, 0xd1, 0x8f, 0xba,
1972 0xf0, 0x2b, 0xb0, 0x42, 0xc6, 0xe3, 0xe4, 0x95, 0x95, 0xbc, 0xc9, 0x6d, 0x3d, 0xab, 0xba, 0x25,
1973 0xfa, 0x0c, 0x1a, 0x5e, 0x30, 0x10, 0xd4, 0xa7, 0x41, 0xe4, 0x10, 0x9f, 0x4f, 0x82, 0x48, 0xed,
1974 0x4f, 0x51, 0x5e, 0xfd, 0x89, 0x65, 0x5f, 0x19, 0x7a, 0x65, 0x28, 0x89, 0x09, 0xa3, 0x3d, 0x0f,
1975 0xb6, 0x06, 0xdc, 0x5f, 0x90, 0xc3, 0xde, 0x5a, 0xcf, 0x0c, 0x1e, 0x90, 0x88, 0xbc, 0x94, 0x3f,
1976 0xab, 0x2f, 0xad, 0xb7, 0xdf, 0x18, 0xe0, 0x88, 0x33, 0x12, 0x8c, 0xba, 0x5c, 0x8c, 0x76, 0x47,
1977 0x34, 0x50, 0xbf, 0xb2, 0xbb, 0xda, 0x44, 0xc6, 0x5e, 0x98, 0xfd, 0xeb, 0xbd, 0x13, 0x7f, 0x1f,
1978 0x96, 0x15, 0xec, 0xe6, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x3e, 0x54, 0x66, 0x7c, 0x1b, 0x0f,