vendor/google.golang.org/genproto/googleapis/bigtable/v1/bigtable_service_messages.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: google/bigtable/v1/bigtable_service_messages.proto
   3
   4 package bigtable
   5
   6 import proto "github.com/golang/protobuf/proto"
   7 import fmt "fmt"
   8 import math "math"
   9 import google_rpc "google.golang.org/genproto/googleapis/rpc/status"
  10
  11 // Reference imports to suppress errors if they are not otherwise used.
  12 var _ = proto.Marshal
  13 var _ = fmt.Errorf
  14 var _ = math.Inf
  15
  16 // Request message for BigtableServer.ReadRows.
  17 type ReadRowsRequest struct {
  18         // The unique name of the table from which to read.
  19         TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
  20         // If neither row_key nor row_range is set, reads from all rows.
  21         //
  22         // Types that are valid to be assigned to Target:
  23         //      *ReadRowsRequest_RowKey
  24         //      *ReadRowsRequest_RowRange
  25         //      *ReadRowsRequest_RowSet
  26         Target isReadRowsRequest_Target `protobuf_oneof:"target"`
  27         // The filter to apply to the contents of the specified row(s). If unset,
  28         // reads the entire table.
  29         Filter *RowFilter `protobuf:"bytes,5,opt,name=filter" json:"filter,omitempty"`
  30         // By default, rows are read sequentially, producing results which are
  31         // guaranteed to arrive in increasing row order. Setting
  32         // "allow_row_interleaving" to true allows multiple rows to be interleaved in
  33         // the response stream, which increases throughput but breaks this guarantee,
  34         // and may force the client to use more memory to buffer partially-received
  35         // rows. Cannot be set to true when specifying "num_rows_limit".
  36         AllowRowInterleaving bool `protobuf:"varint,6,opt,name=allow_row_interleaving,json=allowRowInterleaving" json:"allow_row_interleaving,omitempty"`
  37         // The read will terminate after committing to N rows' worth of results. The
  38         // default (zero) is to return all results.
  39         // Note that "allow_row_interleaving" cannot be set to true when this is set.
  40         NumRowsLimit int64 `protobuf:"varint,7,opt,name=num_rows_limit,json=numRowsLimit" json:"num_rows_limit,omitempty"`
  41 }
  42
  43 func (m *ReadRowsRequest) Reset()                    { *m = ReadRowsRequest{} }
  44 func (m *ReadRowsRequest) String() string            { return proto.CompactTextString(m) }
  45 func (*ReadRowsRequest) ProtoMessage()               {}
  46 func (*ReadRowsRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
  47
  48 type isReadRowsRequest_Target interface {
  49         isReadRowsRequest_Target()
  50 }
  51
  52 type ReadRowsRequest_RowKey struct {
  53         RowKey []byte `protobuf:"bytes,2,opt,name=row_key,json=rowKey,proto3,oneof"`
  54 }
  55 type ReadRowsRequest_RowRange struct {
  56         RowRange *RowRange `protobuf:"bytes,3,opt,name=row_range,json=rowRange,oneof"`
  57 }
  58 type ReadRowsRequest_RowSet struct {
  59         RowSet *RowSet `protobuf:"bytes,8,opt,name=row_set,json=rowSet,oneof"`
  60 }
  61
  62 func (*ReadRowsRequest_RowKey) isReadRowsRequest_Target()   {}
  63 func (*ReadRowsRequest_RowRange) isReadRowsRequest_Target() {}
  64 func (*ReadRowsRequest_RowSet) isReadRowsRequest_Target()   {}
  65
  66 func (m *ReadRowsRequest) GetTarget() isReadRowsRequest_Target {
  67         if m != nil {
  68                 return m.Target
  69         }
  70         return nil
  71 }
  72
  73 func (m *ReadRowsRequest) GetTableName() string {
  74         if m != nil {
  75                 return m.TableName
  76         }
  77         return ""
  78 }
  79
  80 func (m *ReadRowsRequest) GetRowKey() []byte {
  81         if x, ok := m.GetTarget().(*ReadRowsRequest_RowKey); ok {
  82                 return x.RowKey
  83         }
  84         return nil
  85 }
  86
  87 func (m *ReadRowsRequest) GetRowRange() *RowRange {
  88         if x, ok := m.GetTarget().(*ReadRowsRequest_RowRange); ok {
  89                 return x.RowRange
  90         }
  91         return nil
  92 }
  93
  94 func (m *ReadRowsRequest) GetRowSet() *RowSet {
  95         if x, ok := m.GetTarget().(*ReadRowsRequest_RowSet); ok {
  96                 return x.RowSet
  97         }
  98         return nil
  99 }
 100
 101 func (m *ReadRowsRequest) GetFilter() *RowFilter {
 102         if m != nil {
 103                 return m.Filter
 104         }
 105         return nil
 106 }
 107
 108 func (m *ReadRowsRequest) GetAllowRowInterleaving() bool {
 109         if m != nil {
 110                 return m.AllowRowInterleaving
 111         }
 112         return false
 113 }
 114
 115 func (m *ReadRowsRequest) GetNumRowsLimit() int64 {
 116         if m != nil {
 117                 return m.NumRowsLimit
 118         }
 119         return 0
 120 }
 121
 122 // XXX_OneofFuncs is for the internal use of the proto package.
 123 func (*ReadRowsRequest) 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{}) {
 124         return _ReadRowsRequest_OneofMarshaler, _ReadRowsRequest_OneofUnmarshaler, _ReadRowsRequest_OneofSizer, []interface{}{
 125                 (*ReadRowsRequest_RowKey)(nil),
 126                 (*ReadRowsRequest_RowRange)(nil),
 127                 (*ReadRowsRequest_RowSet)(nil),
 128         }
 129 }
 130
 131 func _ReadRowsRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 132         m := msg.(*ReadRowsRequest)
 133         // target
 134         switch x := m.Target.(type) {
 135         case *ReadRowsRequest_RowKey:
 136                 b.EncodeVarint(2<<3 | proto.WireBytes)
 137                 b.EncodeRawBytes(x.RowKey)
 138         case *ReadRowsRequest_RowRange:
 139                 b.EncodeVarint(3<<3 | proto.WireBytes)
 140                 if err := b.EncodeMessage(x.RowRange); err != nil {
 141                         return err
 142                 }
 143         case *ReadRowsRequest_RowSet:
 144                 b.EncodeVarint(8<<3 | proto.WireBytes)
 145                 if err := b.EncodeMessage(x.RowSet); err != nil {
 146                         return err
 147                 }
 148         case nil:
 149         default:
 150                 return fmt.Errorf("ReadRowsRequest.Target has unexpected type %T", x)
 151         }
 152         return nil
 153 }
 154
 155 func _ReadRowsRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 156         m := msg.(*ReadRowsRequest)
 157         switch tag {
 158         case 2: // target.row_key
 159                 if wire != proto.WireBytes {
 160                         return true, proto.ErrInternalBadWireType
 161                 }
 162                 x, err := b.DecodeRawBytes(true)
 163                 m.Target = &ReadRowsRequest_RowKey{x}
 164                 return true, err
 165         case 3: // target.row_range
 166                 if wire != proto.WireBytes {
 167                         return true, proto.ErrInternalBadWireType
 168                 }
 169                 msg := new(RowRange)
 170                 err := b.DecodeMessage(msg)
 171                 m.Target = &ReadRowsRequest_RowRange{msg}
 172                 return true, err
 173         case 8: // target.row_set
 174                 if wire != proto.WireBytes {
 175                         return true, proto.ErrInternalBadWireType
 176                 }
 177                 msg := new(RowSet)
 178                 err := b.DecodeMessage(msg)
 179                 m.Target = &ReadRowsRequest_RowSet{msg}
 180                 return true, err
 181         default:
 182                 return false, nil
 183         }
 184 }
 185
 186 func _ReadRowsRequest_OneofSizer(msg proto.Message) (n int) {
 187         m := msg.(*ReadRowsRequest)
 188         // target
 189         switch x := m.Target.(type) {
 190         case *ReadRowsRequest_RowKey:
 191                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
 192                 n += proto.SizeVarint(uint64(len(x.RowKey)))
 193                 n += len(x.RowKey)
 194         case *ReadRowsRequest_RowRange:
 195                 s := proto.Size(x.RowRange)
 196                 n += proto.SizeVarint(3<<3 | proto.WireBytes)
 197                 n += proto.SizeVarint(uint64(s))
 198                 n += s
 199         case *ReadRowsRequest_RowSet:
 200                 s := proto.Size(x.RowSet)
 201                 n += proto.SizeVarint(8<<3 | proto.WireBytes)
 202                 n += proto.SizeVarint(uint64(s))
 203                 n += s
 204         case nil:
 205         default:
 206                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 207         }
 208         return n
 209 }
 210
 211 // Response message for BigtableService.ReadRows.
 212 type ReadRowsResponse struct {
 213         // The key of the row for which we're receiving data.
 214         // Results will be received in increasing row key order, unless
 215         // "allow_row_interleaving" was specified in the request.
 216         RowKey []byte `protobuf:"bytes,1,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
 217         // One or more chunks of the row specified by "row_key".
 218         Chunks []*ReadRowsResponse_Chunk `protobuf:"bytes,2,rep,name=chunks" json:"chunks,omitempty"`
 219 }
 220
 221 func (m *ReadRowsResponse) Reset()                    { *m = ReadRowsResponse{} }
 222 func (m *ReadRowsResponse) String() string            { return proto.CompactTextString(m) }
 223 func (*ReadRowsResponse) ProtoMessage()               {}
 224 func (*ReadRowsResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} }
 225
 226 func (m *ReadRowsResponse) GetRowKey() []byte {
 227         if m != nil {
 228                 return m.RowKey
 229         }
 230         return nil
 231 }
 232
 233 func (m *ReadRowsResponse) GetChunks() []*ReadRowsResponse_Chunk {
 234         if m != nil {
 235                 return m.Chunks
 236         }
 237         return nil
 238 }
 239
 240 // Specifies a piece of a row's contents returned as part of the read
 241 // response stream.
 242 type ReadRowsResponse_Chunk struct {
 243         // Types that are valid to be assigned to Chunk:
 244         //      *ReadRowsResponse_Chunk_RowContents
 245         //      *ReadRowsResponse_Chunk_ResetRow
 246         //      *ReadRowsResponse_Chunk_CommitRow
 247         Chunk isReadRowsResponse_Chunk_Chunk `protobuf_oneof:"chunk"`
 248 }
 249
 250 func (m *ReadRowsResponse_Chunk) Reset()                    { *m = ReadRowsResponse_Chunk{} }
 251 func (m *ReadRowsResponse_Chunk) String() string            { return proto.CompactTextString(m) }
 252 func (*ReadRowsResponse_Chunk) ProtoMessage()               {}
 253 func (*ReadRowsResponse_Chunk) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1, 0} }
 254
 255 type isReadRowsResponse_Chunk_Chunk interface {
 256         isReadRowsResponse_Chunk_Chunk()
 257 }
 258
 259 type ReadRowsResponse_Chunk_RowContents struct {
 260         RowContents *Family `protobuf:"bytes,1,opt,name=row_contents,json=rowContents,oneof"`
 261 }
 262 type ReadRowsResponse_Chunk_ResetRow struct {
 263         ResetRow bool `protobuf:"varint,2,opt,name=reset_row,json=resetRow,oneof"`
 264 }
 265 type ReadRowsResponse_Chunk_CommitRow struct {
 266         CommitRow bool `protobuf:"varint,3,opt,name=commit_row,json=commitRow,oneof"`
 267 }
 268
 269 func (*ReadRowsResponse_Chunk_RowContents) isReadRowsResponse_Chunk_Chunk() {}
 270 func (*ReadRowsResponse_Chunk_ResetRow) isReadRowsResponse_Chunk_Chunk()    {}
 271 func (*ReadRowsResponse_Chunk_CommitRow) isReadRowsResponse_Chunk_Chunk()   {}
 272
 273 func (m *ReadRowsResponse_Chunk) GetChunk() isReadRowsResponse_Chunk_Chunk {
 274         if m != nil {
 275                 return m.Chunk
 276         }
 277         return nil
 278 }
 279
 280 func (m *ReadRowsResponse_Chunk) GetRowContents() *Family {
 281         if x, ok := m.GetChunk().(*ReadRowsResponse_Chunk_RowContents); ok {
 282                 return x.RowContents
 283         }
 284         return nil
 285 }
 286
 287 func (m *ReadRowsResponse_Chunk) GetResetRow() bool {
 288         if x, ok := m.GetChunk().(*ReadRowsResponse_Chunk_ResetRow); ok {
 289                 return x.ResetRow
 290         }
 291         return false
 292 }
 293
 294 func (m *ReadRowsResponse_Chunk) GetCommitRow() bool {
 295         if x, ok := m.GetChunk().(*ReadRowsResponse_Chunk_CommitRow); ok {
 296                 return x.CommitRow
 297         }
 298         return false
 299 }
 300
 301 // XXX_OneofFuncs is for the internal use of the proto package.
 302 func (*ReadRowsResponse_Chunk) 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{}) {
 303         return _ReadRowsResponse_Chunk_OneofMarshaler, _ReadRowsResponse_Chunk_OneofUnmarshaler, _ReadRowsResponse_Chunk_OneofSizer, []interface{}{
 304                 (*ReadRowsResponse_Chunk_RowContents)(nil),
 305                 (*ReadRowsResponse_Chunk_ResetRow)(nil),
 306                 (*ReadRowsResponse_Chunk_CommitRow)(nil),
 307         }
 308 }
 309
 310 func _ReadRowsResponse_Chunk_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 311         m := msg.(*ReadRowsResponse_Chunk)
 312         // chunk
 313         switch x := m.Chunk.(type) {
 314         case *ReadRowsResponse_Chunk_RowContents:
 315                 b.EncodeVarint(1<<3 | proto.WireBytes)
 316                 if err := b.EncodeMessage(x.RowContents); err != nil {
 317                         return err
 318                 }
 319         case *ReadRowsResponse_Chunk_ResetRow:
 320                 t := uint64(0)
 321                 if x.ResetRow {
 322                         t = 1
 323                 }
 324                 b.EncodeVarint(2<<3 | proto.WireVarint)
 325                 b.EncodeVarint(t)
 326         case *ReadRowsResponse_Chunk_CommitRow:
 327                 t := uint64(0)
 328                 if x.CommitRow {
 329                         t = 1
 330                 }
 331                 b.EncodeVarint(3<<3 | proto.WireVarint)
 332                 b.EncodeVarint(t)
 333         case nil:
 334         default:
 335                 return fmt.Errorf("ReadRowsResponse_Chunk.Chunk has unexpected type %T", x)
 336         }
 337         return nil
 338 }
 339
 340 func _ReadRowsResponse_Chunk_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 341         m := msg.(*ReadRowsResponse_Chunk)
 342         switch tag {
 343         case 1: // chunk.row_contents
 344                 if wire != proto.WireBytes {
 345                         return true, proto.ErrInternalBadWireType
 346                 }
 347                 msg := new(Family)
 348                 err := b.DecodeMessage(msg)
 349                 m.Chunk = &ReadRowsResponse_Chunk_RowContents{msg}
 350                 return true, err
 351         case 2: // chunk.reset_row
 352                 if wire != proto.WireVarint {
 353                         return true, proto.ErrInternalBadWireType
 354                 }
 355                 x, err := b.DecodeVarint()
 356                 m.Chunk = &ReadRowsResponse_Chunk_ResetRow{x != 0}
 357                 return true, err
 358         case 3: // chunk.commit_row
 359                 if wire != proto.WireVarint {
 360                         return true, proto.ErrInternalBadWireType
 361                 }
 362                 x, err := b.DecodeVarint()
 363                 m.Chunk = &ReadRowsResponse_Chunk_CommitRow{x != 0}
 364                 return true, err
 365         default:
 366                 return false, nil
 367         }
 368 }
 369
 370 func _ReadRowsResponse_Chunk_OneofSizer(msg proto.Message) (n int) {
 371         m := msg.(*ReadRowsResponse_Chunk)
 372         // chunk
 373         switch x := m.Chunk.(type) {
 374         case *ReadRowsResponse_Chunk_RowContents:
 375                 s := proto.Size(x.RowContents)
 376                 n += proto.SizeVarint(1<<3 | proto.WireBytes)
 377                 n += proto.SizeVarint(uint64(s))
 378                 n += s
 379         case *ReadRowsResponse_Chunk_ResetRow:
 380                 n += proto.SizeVarint(2<<3 | proto.WireVarint)
 381                 n += 1
 382         case *ReadRowsResponse_Chunk_CommitRow:
 383                 n += proto.SizeVarint(3<<3 | proto.WireVarint)
 384                 n += 1
 385         case nil:
 386         default:
 387                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 388         }
 389         return n
 390 }
 391
 392 // Request message for BigtableService.SampleRowKeys.
 393 type SampleRowKeysRequest struct {
 394         // The unique name of the table from which to sample row keys.
 395         TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
 396 }
 397
 398 func (m *SampleRowKeysRequest) Reset()                    { *m = SampleRowKeysRequest{} }
 399 func (m *SampleRowKeysRequest) String() string            { return proto.CompactTextString(m) }
 400 func (*SampleRowKeysRequest) ProtoMessage()               {}
 401 func (*SampleRowKeysRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{2} }
 402
 403 func (m *SampleRowKeysRequest) GetTableName() string {
 404         if m != nil {
 405                 return m.TableName
 406         }
 407         return ""
 408 }
 409
 410 // Response message for BigtableService.SampleRowKeys.
 411 type SampleRowKeysResponse struct {
 412         // Sorted streamed sequence of sample row keys in the table. The table might
 413         // have contents before the first row key in the list and after the last one,
 414         // but a key containing the empty string indicates "end of table" and will be
 415         // the last response given, if present.
 416         // Note that row keys in this list may not have ever been written to or read
 417         // from, and users should therefore not make any assumptions about the row key
 418         // structure that are specific to their use case.
 419         RowKey []byte `protobuf:"bytes,1,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
 420         // Approximate total storage space used by all rows in the table which precede
 421         // "row_key". Buffering the contents of all rows between two subsequent
 422         // samples would require space roughly equal to the difference in their
 423         // "offset_bytes" fields.
 424         OffsetBytes int64 `protobuf:"varint,2,opt,name=offset_bytes,json=offsetBytes" json:"offset_bytes,omitempty"`
 425 }
 426
 427 func (m *SampleRowKeysResponse) Reset()                    { *m = SampleRowKeysResponse{} }
 428 func (m *SampleRowKeysResponse) String() string            { return proto.CompactTextString(m) }
 429 func (*SampleRowKeysResponse) ProtoMessage()               {}
 430 func (*SampleRowKeysResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{3} }
 431
 432 func (m *SampleRowKeysResponse) GetRowKey() []byte {
 433         if m != nil {
 434                 return m.RowKey
 435         }
 436         return nil
 437 }
 438
 439 func (m *SampleRowKeysResponse) GetOffsetBytes() int64 {
 440         if m != nil {
 441                 return m.OffsetBytes
 442         }
 443         return 0
 444 }
 445
 446 // Request message for BigtableService.MutateRow.
 447 type MutateRowRequest struct {
 448         // The unique name of the table to which the mutation should be applied.
 449         TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
 450         // The key of the row to which the mutation should be applied.
 451         RowKey []byte `protobuf:"bytes,2,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
 452         // Changes to be atomically applied to the specified row. Entries are applied
 453         // in order, meaning that earlier mutations can be masked by later ones.
 454         // Must contain at least one entry and at most 100000.
 455         Mutations []*Mutation `protobuf:"bytes,3,rep,name=mutations" json:"mutations,omitempty"`
 456 }
 457
 458 func (m *MutateRowRequest) Reset()                    { *m = MutateRowRequest{} }
 459 func (m *MutateRowRequest) String() string            { return proto.CompactTextString(m) }
 460 func (*MutateRowRequest) ProtoMessage()               {}
 461 func (*MutateRowRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{4} }
 462
 463 func (m *MutateRowRequest) GetTableName() string {
 464         if m != nil {
 465                 return m.TableName
 466         }
 467         return ""
 468 }
 469
 470 func (m *MutateRowRequest) GetRowKey() []byte {
 471         if m != nil {
 472                 return m.RowKey
 473         }
 474         return nil
 475 }
 476
 477 func (m *MutateRowRequest) GetMutations() []*Mutation {
 478         if m != nil {
 479                 return m.Mutations
 480         }
 481         return nil
 482 }
 483
 484 // Request message for BigtableService.MutateRows.
 485 type MutateRowsRequest struct {
 486         // The unique name of the table to which the mutations should be applied.
 487         TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
 488         // The row keys/mutations to be applied in bulk.
 489         // Each entry is applied as an atomic mutation, but the entries may be
 490         // applied in arbitrary order (even between entries for the same row).
 491         // At least one entry must be specified, and in total the entries may
 492         // contain at most 100000 mutations.
 493         Entries []*MutateRowsRequest_Entry `protobuf:"bytes,2,rep,name=entries" json:"entries,omitempty"`
 494 }
 495
 496 func (m *MutateRowsRequest) Reset()                    { *m = MutateRowsRequest{} }
 497 func (m *MutateRowsRequest) String() string            { return proto.CompactTextString(m) }
 498 func (*MutateRowsRequest) ProtoMessage()               {}
 499 func (*MutateRowsRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{5} }
 500
 501 func (m *MutateRowsRequest) GetTableName() string {
 502         if m != nil {
 503                 return m.TableName
 504         }
 505         return ""
 506 }
 507
 508 func (m *MutateRowsRequest) GetEntries() []*MutateRowsRequest_Entry {
 509         if m != nil {
 510                 return m.Entries
 511         }
 512         return nil
 513 }
 514
 515 type MutateRowsRequest_Entry struct {
 516         // The key of the row to which the `mutations` should be applied.
 517         RowKey []byte `protobuf:"bytes,1,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
 518         // Changes to be atomically applied to the specified row. Mutations are
 519         // applied in order, meaning that earlier mutations can be masked by
 520         // later ones.
 521         // At least one mutation must be specified.
 522         Mutations []*Mutation `protobuf:"bytes,2,rep,name=mutations" json:"mutations,omitempty"`
 523 }
 524
 525 func (m *MutateRowsRequest_Entry) Reset()                    { *m = MutateRowsRequest_Entry{} }
 526 func (m *MutateRowsRequest_Entry) String() string            { return proto.CompactTextString(m) }
 527 func (*MutateRowsRequest_Entry) ProtoMessage()               {}
 528 func (*MutateRowsRequest_Entry) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{5, 0} }
 529
 530 func (m *MutateRowsRequest_Entry) GetRowKey() []byte {
 531         if m != nil {
 532                 return m.RowKey
 533         }
 534         return nil
 535 }
 536
 537 func (m *MutateRowsRequest_Entry) GetMutations() []*Mutation {
 538         if m != nil {
 539                 return m.Mutations
 540         }
 541         return nil
 542 }
 543
 544 // Response message for BigtableService.MutateRows.
 545 type MutateRowsResponse struct {
 546         // The results for each Entry from the request, presented in the order
 547         // in which the entries were originally given.
 548         // Depending on how requests are batched during execution, it is possible
 549         // for one Entry to fail due to an error with another Entry. In the event
 550         // that this occurs, the same error will be reported for both entries.
 551         Statuses []*google_rpc.Status `protobuf:"bytes,1,rep,name=statuses" json:"statuses,omitempty"`
 552 }
 553
 554 func (m *MutateRowsResponse) Reset()                    { *m = MutateRowsResponse{} }
 555 func (m *MutateRowsResponse) String() string            { return proto.CompactTextString(m) }
 556 func (*MutateRowsResponse) ProtoMessage()               {}
 557 func (*MutateRowsResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{6} }
 558
 559 func (m *MutateRowsResponse) GetStatuses() []*google_rpc.Status {
 560         if m != nil {
 561                 return m.Statuses
 562         }
 563         return nil
 564 }
 565
 566 // Request message for BigtableService.CheckAndMutateRowRequest
 567 type CheckAndMutateRowRequest struct {
 568         // The unique name of the table to which the conditional mutation should be
 569         // applied.
 570         TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
 571         // The key of the row to which the conditional mutation should be applied.
 572         RowKey []byte `protobuf:"bytes,2,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
 573         // The filter to be applied to the contents of the specified row. Depending
 574         // on whether or not any results are yielded, either "true_mutations" or
 575         // "false_mutations" will be executed. If unset, checks that the row contains
 576         // any values at all.
 577         PredicateFilter *RowFilter `protobuf:"bytes,6,opt,name=predicate_filter,json=predicateFilter" json:"predicate_filter,omitempty"`
 578         // Changes to be atomically applied to the specified row if "predicate_filter"
 579         // yields at least one cell when applied to "row_key". Entries are applied in
 580         // order, meaning that earlier mutations can be masked by later ones.
 581         // Must contain at least one entry if "false_mutations" is empty, and at most
 582         // 100000.
 583         TrueMutations []*Mutation `protobuf:"bytes,4,rep,name=true_mutations,json=trueMutations" json:"true_mutations,omitempty"`
 584         // Changes to be atomically applied to the specified row if "predicate_filter"
 585         // does not yield any cells when applied to "row_key". Entries are applied in
 586         // order, meaning that earlier mutations can be masked by later ones.
 587         // Must contain at least one entry if "true_mutations" is empty, and at most
 588         // 100000.
 589         FalseMutations []*Mutation `protobuf:"bytes,5,rep,name=false_mutations,json=falseMutations" json:"false_mutations,omitempty"`
 590 }
 591
 592 func (m *CheckAndMutateRowRequest) Reset()                    { *m = CheckAndMutateRowRequest{} }
 593 func (m *CheckAndMutateRowRequest) String() string            { return proto.CompactTextString(m) }
 594 func (*CheckAndMutateRowRequest) ProtoMessage()               {}
 595 func (*CheckAndMutateRowRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{7} }
 596
 597 func (m *CheckAndMutateRowRequest) GetTableName() string {
 598         if m != nil {
 599                 return m.TableName
 600         }
 601         return ""
 602 }
 603
 604 func (m *CheckAndMutateRowRequest) GetRowKey() []byte {
 605         if m != nil {
 606                 return m.RowKey
 607         }
 608         return nil
 609 }
 610
 611 func (m *CheckAndMutateRowRequest) GetPredicateFilter() *RowFilter {
 612         if m != nil {
 613                 return m.PredicateFilter
 614         }
 615         return nil
 616 }
 617
 618 func (m *CheckAndMutateRowRequest) GetTrueMutations() []*Mutation {
 619         if m != nil {
 620                 return m.TrueMutations
 621         }
 622         return nil
 623 }
 624
 625 func (m *CheckAndMutateRowRequest) GetFalseMutations() []*Mutation {
 626         if m != nil {
 627                 return m.FalseMutations
 628         }
 629         return nil
 630 }
 631
 632 // Response message for BigtableService.CheckAndMutateRowRequest.
 633 type CheckAndMutateRowResponse struct {
 634         // Whether or not the request's "predicate_filter" yielded any results for
 635         // the specified row.
 636         PredicateMatched bool `protobuf:"varint,1,opt,name=predicate_matched,json=predicateMatched" json:"predicate_matched,omitempty"`
 637 }
 638
 639 func (m *CheckAndMutateRowResponse) Reset()                    { *m = CheckAndMutateRowResponse{} }
 640 func (m *CheckAndMutateRowResponse) String() string            { return proto.CompactTextString(m) }
 641 func (*CheckAndMutateRowResponse) ProtoMessage()               {}
 642 func (*CheckAndMutateRowResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{8} }
 643
 644 func (m *CheckAndMutateRowResponse) GetPredicateMatched() bool {
 645         if m != nil {
 646                 return m.PredicateMatched
 647         }
 648         return false
 649 }
 650
 651 // Request message for BigtableService.ReadModifyWriteRowRequest.
 652 type ReadModifyWriteRowRequest struct {
 653         // The unique name of the table to which the read/modify/write rules should be
 654         // applied.
 655         TableName string `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
 656         // The key of the row to which the read/modify/write rules should be applied.
 657         RowKey []byte `protobuf:"bytes,2,opt,name=row_key,json=rowKey,proto3" json:"row_key,omitempty"`
 658         // Rules specifying how the specified row's contents are to be transformed
 659         // into writes. Entries are applied in order, meaning that earlier rules will
 660         // affect the results of later ones.
 661         Rules []*ReadModifyWriteRule `protobuf:"bytes,3,rep,name=rules" json:"rules,omitempty"`
 662 }
 663
 664 func (m *ReadModifyWriteRowRequest) Reset()                    { *m = ReadModifyWriteRowRequest{} }
 665 func (m *ReadModifyWriteRowRequest) String() string            { return proto.CompactTextString(m) }
 666 func (*ReadModifyWriteRowRequest) ProtoMessage()               {}
 667 func (*ReadModifyWriteRowRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{9} }
 668
 669 func (m *ReadModifyWriteRowRequest) GetTableName() string {
 670         if m != nil {
 671                 return m.TableName
 672         }
 673         return ""
 674 }
 675
 676 func (m *ReadModifyWriteRowRequest) GetRowKey() []byte {
 677         if m != nil {
 678                 return m.RowKey
 679         }
 680         return nil
 681 }
 682
 683 func (m *ReadModifyWriteRowRequest) GetRules() []*ReadModifyWriteRule {
 684         if m != nil {
 685                 return m.Rules
 686         }
 687         return nil
 688 }
 689
 690 func init() {
 691         proto.RegisterType((*ReadRowsRequest)(nil), "google.bigtable.v1.ReadRowsRequest")
 692         proto.RegisterType((*ReadRowsResponse)(nil), "google.bigtable.v1.ReadRowsResponse")
 693         proto.RegisterType((*ReadRowsResponse_Chunk)(nil), "google.bigtable.v1.ReadRowsResponse.Chunk")
 694         proto.RegisterType((*SampleRowKeysRequest)(nil), "google.bigtable.v1.SampleRowKeysRequest")
 695         proto.RegisterType((*SampleRowKeysResponse)(nil), "google.bigtable.v1.SampleRowKeysResponse")
 696         proto.RegisterType((*MutateRowRequest)(nil), "google.bigtable.v1.MutateRowRequest")
 697         proto.RegisterType((*MutateRowsRequest)(nil), "google.bigtable.v1.MutateRowsRequest")
 698         proto.RegisterType((*MutateRowsRequest_Entry)(nil), "google.bigtable.v1.MutateRowsRequest.Entry")
 699         proto.RegisterType((*MutateRowsResponse)(nil), "google.bigtable.v1.MutateRowsResponse")
 700         proto.RegisterType((*CheckAndMutateRowRequest)(nil), "google.bigtable.v1.CheckAndMutateRowRequest")
 701         proto.RegisterType((*CheckAndMutateRowResponse)(nil), "google.bigtable.v1.CheckAndMutateRowResponse")
 702         proto.RegisterType((*ReadModifyWriteRowRequest)(nil), "google.bigtable.v1.ReadModifyWriteRowRequest")
 703 }
 704
 705 func init() { proto.RegisterFile("google/bigtable/v1/bigtable_service_messages.proto", fileDescriptor2) }
 706
 707 var fileDescriptor2 = []byte{
 708         // 788 bytes of a gzipped FileDescriptorProto
 709         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0x5f, 0x8b, 0x23, 0x45,
 710         0x10, 0xdf, 0x49, 0xcc, 0xbf, 0x4a, 0xdc, 0xdd, 0x6b, 0xce, 0xdb, 0xd9, 0x70, 0x8b, 0x71, 0x10,
 711         0x0d, 0x1e, 0x4c, 0xb8, 0xd5, 0x7d, 0xb9, 0x43, 0xc4, 0xc4, 0x3d, 0x22, 0x1a, 0x39, 0x3a, 0x0f,
 712         0x82, 0x08, 0xa1, 0x33, 0xa9, 0xcc, 0x0e, 0x3b, 0xd3, 0x1d, 0xbb, 0x7b, 0x32, 0xe4, 0x59, 0xf0,
 713         0x5d, 0x3f, 0x85, 0xdf, 0xc8, 0x17, 0x3f, 0x8c, 0x74, 0xcf, 0xe4, 0x8f, 0x6b, 0xa2, 0x11, 0xf6,
 714         0xad, 0xa7, 0xaa, 0x7e, 0xbf, 0xaa, 0xfa, 0x75, 0x4d, 0x17, 0x5c, 0x87, 0x42, 0x84, 0x31, 0xf6,
 715         0xa6, 0x51, 0xa8, 0xd9, 0x34, 0xc6, 0xde, 0xf2, 0xe5, 0xe6, 0x3c, 0x51, 0x28, 0x97, 0x51, 0x80,
 716         0x93, 0x04, 0x95, 0x62, 0x21, 0x2a, 0x7f, 0x21, 0x85, 0x16, 0x84, 0xe4, 0x18, 0x7f, 0x1d, 0xe7,
 717         0x2f, 0x5f, 0xb6, 0x3f, 0xfa, 0x37, 0x9e, 0x19, 0xd3, 0x2c, 0xc7, 0xb6, 0x2f, 0x8a, 0x38, 0xb9,
 718         0x08, 0x7a, 0x4a, 0x33, 0x9d, 0x16, 0xa4, 0xde, 0x9f, 0x25, 0x38, 0xa3, 0xc8, 0x66, 0x54, 0x64,
 719         0x8a, 0xe2, 0x4f, 0x29, 0x2a, 0x4d, 0xae, 0x00, 0x72, 0x02, 0xce, 0x12, 0x74, 0x9d, 0x8e, 0xd3,
 720         0x6d, 0xd0, 0x86, 0xb5, 0x7c, 0xc7, 0x12, 0x24, 0x97, 0x50, 0x93, 0x22, 0x9b, 0xdc, 0xe3, 0xca,
 721         0x2d, 0x75, 0x9c, 0x6e, 0x6b, 0x78, 0x42, 0xab, 0x52, 0x64, 0xdf, 0xe0, 0x8a, 0xbc, 0x86, 0x86,
 722         0x71, 0x49, 0xc6, 0x43, 0x74, 0xcb, 0x1d, 0xa7, 0xdb, 0xbc, 0x7e, 0xee, 0xff, 0xb3, 0x6c, 0x9f,
 723         0x8a, 0x8c, 0x9a, 0x98, 0xe1, 0x09, 0xad, 0xcb, 0xe2, 0x4c, 0x6e, 0x72, 0x5e, 0x85, 0xda, 0xad,
 724         0x5b, 0x68, 0xfb, 0x00, 0x74, 0x8c, 0xba, 0xc8, 0x39, 0x46, 0x4d, 0x6e, 0xa0, 0x3a, 0x8f, 0x62,
 725         0x8d, 0xd2, 0xad, 0x58, 0xd4, 0xd5, 0x01, 0xd4, 0x1b, 0x1b, 0x44, 0x8b, 0x60, 0xf2, 0x19, 0x3c,
 726         0x63, 0x71, 0x6c, 0x8a, 0x15, 0xd9, 0x24, 0xe2, 0x1a, 0x65, 0x8c, 0x6c, 0x19, 0xf1, 0xd0, 0xad,
 727         0x76, 0x9c, 0x6e, 0x9d, 0x3e, 0xb5, 0x5e, 0x2a, 0xb2, 0xaf, 0x77, 0x7c, 0xe4, 0x43, 0x38, 0xe5,
 728         0x69, 0x62, 0x30, 0x6a, 0x12, 0x47, 0x49, 0xa4, 0xdd, 0x5a, 0xc7, 0xe9, 0x96, 0x69, 0x8b, 0xa7,
 729         0x89, 0x91, 0xf0, 0x5b, 0x63, 0xeb, 0xd7, 0xa1, 0xaa, 0x99, 0x0c, 0x51, 0x7b, 0x3f, 0x97, 0xe0,
 730         0x7c, 0x2b, 0xaf, 0x5a, 0x08, 0xae, 0x90, 0x5c, 0x6c, 0x05, 0x34, 0xe2, 0xb6, 0x36, 0xf2, 0xf5,
 731         0xa1, 0x1a, 0xdc, 0xa5, 0xfc, 0x5e, 0xb9, 0xa5, 0x4e, 0xb9, 0xdb, 0xbc, 0xfe, 0x64, 0x6f, 0x2b,
 732         0x0f, 0xe8, 0xfc, 0x81, 0x81, 0xd0, 0x02, 0xd9, 0xfe, 0xd5, 0x81, 0x8a, 0xb5, 0x90, 0x2f, 0xa0,
 733         0x65, 0xd2, 0x04, 0x82, 0x6b, 0xe4, 0x5a, 0xd9, 0x5c, 0x07, 0x44, 0x7d, 0xc3, 0x92, 0x28, 0x5e,
 734         0x0d, 0x4f, 0x68, 0x53, 0x8a, 0x6c, 0x50, 0x00, 0xc8, 0x15, 0x34, 0x24, 0x2a, 0xd4, 0xa6, 0x5d,
 735         0x7b, 0xd5, 0x75, 0x7b, 0x5f, 0xc6, 0x44, 0x45, 0x46, 0xde, 0x07, 0x08, 0x44, 0x92, 0x44, 0xb9,
 736         0xbf, 0x5c, 0xf8, 0x1b, 0xb9, 0x8d, 0x8a, 0xac, 0x5f, 0x83, 0x8a, 0x2d, 0xca, 0xbb, 0x81, 0xa7,
 737         0x63, 0x96, 0x2c, 0x62, 0xa4, 0xb6, 0xcf, 0x23, 0x07, 0xcd, 0x1b, 0xc3, 0x7b, 0x0f, 0x60, 0xff,
 738         0x25, 0xe0, 0x07, 0xd0, 0x12, 0xf3, 0xb9, 0x29, 0x79, 0xba, 0xd2, 0xa8, 0x6c, 0xd1, 0x65, 0xda,
 739         0xcc, 0x6d, 0x7d, 0x63, 0xf2, 0x7e, 0x71, 0xe0, 0x7c, 0x94, 0x6a, 0xa6, 0x0d, 0xeb, 0x91, 0x13,
 740         0x7f, 0xf1, 0x60, 0xe2, 0x37, 0xf9, 0x5e, 0x41, 0x23, 0x31, 0x5c, 0x91, 0xe0, 0xca, 0x2d, 0xdb,
 741         0x3b, 0xdb, 0x3b, 0xef, 0xa3, 0x22, 0x88, 0x6e, 0xc3, 0xbd, 0x3f, 0x1c, 0x78, 0xb2, 0x29, 0xe4,
 742         0xd8, 0x7f, 0xef, 0x16, 0x6a, 0xc8, 0xb5, 0x8c, 0x70, 0x3d, 0x22, 0x2f, 0x0e, 0xa6, 0xdb, 0xa5,
 743         0xf5, 0x6f, 0xb9, 0x96, 0x2b, 0xba, 0xc6, 0xb6, 0x7f, 0x84, 0x8a, 0xb5, 0x1c, 0x56, 0xf2, 0x6f,
 744         0x9d, 0x95, 0xfe, 0x5f, 0x67, 0x5f, 0x01, 0xd9, 0xad, 0xa0, 0xb8, 0x34, 0x1f, 0xea, 0xf9, 0xcb,
 745         0x83, 0x66, 0x14, 0x0d, 0x21, 0x59, 0x13, 0xca, 0x45, 0xe0, 0x8f, 0xad, 0x8f, 0x6e, 0x62, 0xbc,
 746         0xdf, 0x4b, 0xe0, 0x0e, 0xee, 0x30, 0xb8, 0xff, 0x92, 0xcf, 0x1e, 0xed, 0xc2, 0x86, 0x70, 0xbe,
 747         0x90, 0x38, 0x8b, 0x02, 0xa6, 0x71, 0x52, 0x3c, 0x1b, 0xd5, 0x63, 0x9e, 0x8d, 0xb3, 0x0d, 0x2c,
 748         0x37, 0x90, 0x01, 0x9c, 0x6a, 0x99, 0xe2, 0x64, 0xab, 0xd2, 0x3b, 0x47, 0xa8, 0xf4, 0xae, 0xc1,
 749         0xac, 0xbf, 0x14, 0xb9, 0x85, 0xb3, 0x39, 0x8b, 0xd5, 0x2e, 0x4b, 0xe5, 0x08, 0x96, 0x53, 0x0b,
 750         0xda, 0xd0, 0x78, 0x43, 0xb8, 0xdc, 0xa3, 0x54, 0xa1, 0xfb, 0x0b, 0x78, 0xb2, 0x6d, 0x39, 0x61,
 751         0x3a, 0xb8, 0xc3, 0x99, 0x55, 0xac, 0x4e, 0xb7, 0x5a, 0x8c, 0x72, 0xbb, 0xf7, 0x9b, 0x03, 0x97,
 752         0xe6, 0x81, 0x19, 0x89, 0x59, 0x34, 0x5f, 0x7d, 0x2f, 0xa3, 0x47, 0x51, 0xfd, 0x73, 0xa8, 0xc8,
 753         0x34, 0xc6, 0xf5, 0x2f, 0xf2, 0xf1, 0xa1, 0x67, 0x6d, 0x37, 0x6b, 0x1a, 0x23, 0xcd, 0x51, 0x7d,
 754         0x0d, 0xcf, 0x02, 0x91, 0xec, 0x01, 0xf5, 0x9f, 0xf7, 0x8b, 0x8f, 0x71, 0xbe, 0x32, 0x47, 0xc5,
 755         0xc6, 0x7c, 0x6b, 0x76, 0xdb, 0x5b, 0xe7, 0x87, 0x57, 0x05, 0x26, 0x14, 0x31, 0xe3, 0xa1, 0x2f,
 756         0x64, 0xd8, 0x0b, 0x91, 0xdb, 0xcd, 0xd7, 0xcb, 0x5d, 0x6c, 0x11, 0xa9, 0xdd, 0xed, 0xf9, 0x7a,
 757         0x7d, 0x9e, 0x56, 0x6d, 0xd8, 0xa7, 0x7f, 0x05, 0x00, 0x00, 0xff, 0xff, 0x16, 0x55, 0x90, 0x95,
 758         0xab, 0x07, 0x00, 0x00,
 759 }