1// Code generated by protoc-gen-gogo. DO NOT EDIT. 2// source: pkg/storage/chunk/grpc/grpc.proto 3 4package grpc 5 6import ( 7 bytes "bytes" 8 context "context" 9 fmt "fmt" 10 proto "github.com/gogo/protobuf/proto" 11 github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" 12 empty "github.com/golang/protobuf/ptypes/empty" 13 grpc "google.golang.org/grpc" 14 codes "google.golang.org/grpc/codes" 15 status "google.golang.org/grpc/status" 16 io "io" 17 math "math" 18 math_bits "math/bits" 19 reflect "reflect" 20 strings "strings" 21) 22 23// Reference imports to suppress errors if they are not otherwise used. 24var _ = proto.Marshal 25var _ = fmt.Errorf 26var _ = math.Inf 27 28// This is a compile-time assertion to ensure that this generated file 29// is compatible with the proto package it is being compiled against. 30// A compilation error at this line likely means your copy of the 31// proto package needs to be updated. 32const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package 33 34type PutChunksRequest struct { 35 Chunks []*Chunk `protobuf:"bytes,1,rep,name=chunks,proto3" json:"chunks,omitempty"` 36} 37 38func (m *PutChunksRequest) Reset() { *m = PutChunksRequest{} } 39func (*PutChunksRequest) ProtoMessage() {} 40func (*PutChunksRequest) Descriptor() ([]byte, []int) { 41 return fileDescriptor_7322c8818cf62b01, []int{0} 42} 43func (m *PutChunksRequest) XXX_Unmarshal(b []byte) error { 44 return m.Unmarshal(b) 45} 46func (m *PutChunksRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 47 if deterministic { 48 return xxx_messageInfo_PutChunksRequest.Marshal(b, m, deterministic) 49 } else { 50 b = b[:cap(b)] 51 n, err := m.MarshalToSizedBuffer(b) 52 if err != nil { 53 return nil, err 54 } 55 return b[:n], nil 56 } 57} 58func (m *PutChunksRequest) XXX_Merge(src proto.Message) { 59 xxx_messageInfo_PutChunksRequest.Merge(m, src) 60} 61func (m *PutChunksRequest) XXX_Size() int { 62 return m.Size() 63} 64func (m *PutChunksRequest) XXX_DiscardUnknown() { 65 xxx_messageInfo_PutChunksRequest.DiscardUnknown(m) 66} 67 68var xxx_messageInfo_PutChunksRequest proto.InternalMessageInfo 69 70func (m *PutChunksRequest) GetChunks() []*Chunk { 71 if m != nil { 72 return m.Chunks 73 } 74 return nil 75} 76 77type GetChunksRequest struct { 78 Chunks []*Chunk `protobuf:"bytes,1,rep,name=chunks,proto3" json:"chunks,omitempty"` 79} 80 81func (m *GetChunksRequest) Reset() { *m = GetChunksRequest{} } 82func (*GetChunksRequest) ProtoMessage() {} 83func (*GetChunksRequest) Descriptor() ([]byte, []int) { 84 return fileDescriptor_7322c8818cf62b01, []int{1} 85} 86func (m *GetChunksRequest) XXX_Unmarshal(b []byte) error { 87 return m.Unmarshal(b) 88} 89func (m *GetChunksRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 90 if deterministic { 91 return xxx_messageInfo_GetChunksRequest.Marshal(b, m, deterministic) 92 } else { 93 b = b[:cap(b)] 94 n, err := m.MarshalToSizedBuffer(b) 95 if err != nil { 96 return nil, err 97 } 98 return b[:n], nil 99 } 100} 101func (m *GetChunksRequest) XXX_Merge(src proto.Message) { 102 xxx_messageInfo_GetChunksRequest.Merge(m, src) 103} 104func (m *GetChunksRequest) XXX_Size() int { 105 return m.Size() 106} 107func (m *GetChunksRequest) XXX_DiscardUnknown() { 108 xxx_messageInfo_GetChunksRequest.DiscardUnknown(m) 109} 110 111var xxx_messageInfo_GetChunksRequest proto.InternalMessageInfo 112 113func (m *GetChunksRequest) GetChunks() []*Chunk { 114 if m != nil { 115 return m.Chunks 116 } 117 return nil 118} 119 120type GetChunksResponse struct { 121 Chunks []*Chunk `protobuf:"bytes,1,rep,name=chunks,proto3" json:"chunks,omitempty"` 122} 123 124func (m *GetChunksResponse) Reset() { *m = GetChunksResponse{} } 125func (*GetChunksResponse) ProtoMessage() {} 126func (*GetChunksResponse) Descriptor() ([]byte, []int) { 127 return fileDescriptor_7322c8818cf62b01, []int{2} 128} 129func (m *GetChunksResponse) XXX_Unmarshal(b []byte) error { 130 return m.Unmarshal(b) 131} 132func (m *GetChunksResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 133 if deterministic { 134 return xxx_messageInfo_GetChunksResponse.Marshal(b, m, deterministic) 135 } else { 136 b = b[:cap(b)] 137 n, err := m.MarshalToSizedBuffer(b) 138 if err != nil { 139 return nil, err 140 } 141 return b[:n], nil 142 } 143} 144func (m *GetChunksResponse) XXX_Merge(src proto.Message) { 145 xxx_messageInfo_GetChunksResponse.Merge(m, src) 146} 147func (m *GetChunksResponse) XXX_Size() int { 148 return m.Size() 149} 150func (m *GetChunksResponse) XXX_DiscardUnknown() { 151 xxx_messageInfo_GetChunksResponse.DiscardUnknown(m) 152} 153 154var xxx_messageInfo_GetChunksResponse proto.InternalMessageInfo 155 156func (m *GetChunksResponse) GetChunks() []*Chunk { 157 if m != nil { 158 return m.Chunks 159 } 160 return nil 161} 162 163type Chunk struct { 164 Encoded []byte `protobuf:"bytes,1,opt,name=encoded,proto3" json:"encoded,omitempty"` 165 Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` 166 TableName string `protobuf:"bytes,3,opt,name=tableName,proto3" json:"tableName,omitempty"` 167} 168 169func (m *Chunk) Reset() { *m = Chunk{} } 170func (*Chunk) ProtoMessage() {} 171func (*Chunk) Descriptor() ([]byte, []int) { 172 return fileDescriptor_7322c8818cf62b01, []int{3} 173} 174func (m *Chunk) XXX_Unmarshal(b []byte) error { 175 return m.Unmarshal(b) 176} 177func (m *Chunk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 178 if deterministic { 179 return xxx_messageInfo_Chunk.Marshal(b, m, deterministic) 180 } else { 181 b = b[:cap(b)] 182 n, err := m.MarshalToSizedBuffer(b) 183 if err != nil { 184 return nil, err 185 } 186 return b[:n], nil 187 } 188} 189func (m *Chunk) XXX_Merge(src proto.Message) { 190 xxx_messageInfo_Chunk.Merge(m, src) 191} 192func (m *Chunk) XXX_Size() int { 193 return m.Size() 194} 195func (m *Chunk) XXX_DiscardUnknown() { 196 xxx_messageInfo_Chunk.DiscardUnknown(m) 197} 198 199var xxx_messageInfo_Chunk proto.InternalMessageInfo 200 201func (m *Chunk) GetEncoded() []byte { 202 if m != nil { 203 return m.Encoded 204 } 205 return nil 206} 207 208func (m *Chunk) GetKey() string { 209 if m != nil { 210 return m.Key 211 } 212 return "" 213} 214 215func (m *Chunk) GetTableName() string { 216 if m != nil { 217 return m.TableName 218 } 219 return "" 220} 221 222type ChunkID struct { 223 ChunkID string `protobuf:"bytes,1,opt,name=chunkID,proto3" json:"chunkID,omitempty"` 224} 225 226func (m *ChunkID) Reset() { *m = ChunkID{} } 227func (*ChunkID) ProtoMessage() {} 228func (*ChunkID) Descriptor() ([]byte, []int) { 229 return fileDescriptor_7322c8818cf62b01, []int{4} 230} 231func (m *ChunkID) XXX_Unmarshal(b []byte) error { 232 return m.Unmarshal(b) 233} 234func (m *ChunkID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 235 if deterministic { 236 return xxx_messageInfo_ChunkID.Marshal(b, m, deterministic) 237 } else { 238 b = b[:cap(b)] 239 n, err := m.MarshalToSizedBuffer(b) 240 if err != nil { 241 return nil, err 242 } 243 return b[:n], nil 244 } 245} 246func (m *ChunkID) XXX_Merge(src proto.Message) { 247 xxx_messageInfo_ChunkID.Merge(m, src) 248} 249func (m *ChunkID) XXX_Size() int { 250 return m.Size() 251} 252func (m *ChunkID) XXX_DiscardUnknown() { 253 xxx_messageInfo_ChunkID.DiscardUnknown(m) 254} 255 256var xxx_messageInfo_ChunkID proto.InternalMessageInfo 257 258func (m *ChunkID) GetChunkID() string { 259 if m != nil { 260 return m.ChunkID 261 } 262 return "" 263} 264 265type DeleteTableRequest struct { 266 TableName string `protobuf:"bytes,1,opt,name=tableName,proto3" json:"tableName,omitempty"` 267} 268 269func (m *DeleteTableRequest) Reset() { *m = DeleteTableRequest{} } 270func (*DeleteTableRequest) ProtoMessage() {} 271func (*DeleteTableRequest) Descriptor() ([]byte, []int) { 272 return fileDescriptor_7322c8818cf62b01, []int{5} 273} 274func (m *DeleteTableRequest) XXX_Unmarshal(b []byte) error { 275 return m.Unmarshal(b) 276} 277func (m *DeleteTableRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 278 if deterministic { 279 return xxx_messageInfo_DeleteTableRequest.Marshal(b, m, deterministic) 280 } else { 281 b = b[:cap(b)] 282 n, err := m.MarshalToSizedBuffer(b) 283 if err != nil { 284 return nil, err 285 } 286 return b[:n], nil 287 } 288} 289func (m *DeleteTableRequest) XXX_Merge(src proto.Message) { 290 xxx_messageInfo_DeleteTableRequest.Merge(m, src) 291} 292func (m *DeleteTableRequest) XXX_Size() int { 293 return m.Size() 294} 295func (m *DeleteTableRequest) XXX_DiscardUnknown() { 296 xxx_messageInfo_DeleteTableRequest.DiscardUnknown(m) 297} 298 299var xxx_messageInfo_DeleteTableRequest proto.InternalMessageInfo 300 301func (m *DeleteTableRequest) GetTableName() string { 302 if m != nil { 303 return m.TableName 304 } 305 return "" 306} 307 308type DescribeTableRequest struct { 309 TableName string `protobuf:"bytes,1,opt,name=tableName,proto3" json:"tableName,omitempty"` 310} 311 312func (m *DescribeTableRequest) Reset() { *m = DescribeTableRequest{} } 313func (*DescribeTableRequest) ProtoMessage() {} 314func (*DescribeTableRequest) Descriptor() ([]byte, []int) { 315 return fileDescriptor_7322c8818cf62b01, []int{6} 316} 317func (m *DescribeTableRequest) XXX_Unmarshal(b []byte) error { 318 return m.Unmarshal(b) 319} 320func (m *DescribeTableRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 321 if deterministic { 322 return xxx_messageInfo_DescribeTableRequest.Marshal(b, m, deterministic) 323 } else { 324 b = b[:cap(b)] 325 n, err := m.MarshalToSizedBuffer(b) 326 if err != nil { 327 return nil, err 328 } 329 return b[:n], nil 330 } 331} 332func (m *DescribeTableRequest) XXX_Merge(src proto.Message) { 333 xxx_messageInfo_DescribeTableRequest.Merge(m, src) 334} 335func (m *DescribeTableRequest) XXX_Size() int { 336 return m.Size() 337} 338func (m *DescribeTableRequest) XXX_DiscardUnknown() { 339 xxx_messageInfo_DescribeTableRequest.DiscardUnknown(m) 340} 341 342var xxx_messageInfo_DescribeTableRequest proto.InternalMessageInfo 343 344func (m *DescribeTableRequest) GetTableName() string { 345 if m != nil { 346 return m.TableName 347 } 348 return "" 349} 350 351type WriteBatch struct { 352 Writes []*IndexEntry `protobuf:"bytes,1,rep,name=writes,proto3" json:"writes,omitempty"` 353 Deletes []*IndexEntry `protobuf:"bytes,2,rep,name=deletes,proto3" json:"deletes,omitempty"` 354} 355 356func (m *WriteBatch) Reset() { *m = WriteBatch{} } 357func (*WriteBatch) ProtoMessage() {} 358func (*WriteBatch) Descriptor() ([]byte, []int) { 359 return fileDescriptor_7322c8818cf62b01, []int{7} 360} 361func (m *WriteBatch) XXX_Unmarshal(b []byte) error { 362 return m.Unmarshal(b) 363} 364func (m *WriteBatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 365 if deterministic { 366 return xxx_messageInfo_WriteBatch.Marshal(b, m, deterministic) 367 } else { 368 b = b[:cap(b)] 369 n, err := m.MarshalToSizedBuffer(b) 370 if err != nil { 371 return nil, err 372 } 373 return b[:n], nil 374 } 375} 376func (m *WriteBatch) XXX_Merge(src proto.Message) { 377 xxx_messageInfo_WriteBatch.Merge(m, src) 378} 379func (m *WriteBatch) XXX_Size() int { 380 return m.Size() 381} 382func (m *WriteBatch) XXX_DiscardUnknown() { 383 xxx_messageInfo_WriteBatch.DiscardUnknown(m) 384} 385 386var xxx_messageInfo_WriteBatch proto.InternalMessageInfo 387 388func (m *WriteBatch) GetWrites() []*IndexEntry { 389 if m != nil { 390 return m.Writes 391 } 392 return nil 393} 394 395func (m *WriteBatch) GetDeletes() []*IndexEntry { 396 if m != nil { 397 return m.Deletes 398 } 399 return nil 400} 401 402type WriteIndexRequest struct { 403 Writes []*IndexEntry `protobuf:"bytes,1,rep,name=writes,proto3" json:"writes,omitempty"` 404} 405 406func (m *WriteIndexRequest) Reset() { *m = WriteIndexRequest{} } 407func (*WriteIndexRequest) ProtoMessage() {} 408func (*WriteIndexRequest) Descriptor() ([]byte, []int) { 409 return fileDescriptor_7322c8818cf62b01, []int{8} 410} 411func (m *WriteIndexRequest) XXX_Unmarshal(b []byte) error { 412 return m.Unmarshal(b) 413} 414func (m *WriteIndexRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 415 if deterministic { 416 return xxx_messageInfo_WriteIndexRequest.Marshal(b, m, deterministic) 417 } else { 418 b = b[:cap(b)] 419 n, err := m.MarshalToSizedBuffer(b) 420 if err != nil { 421 return nil, err 422 } 423 return b[:n], nil 424 } 425} 426func (m *WriteIndexRequest) XXX_Merge(src proto.Message) { 427 xxx_messageInfo_WriteIndexRequest.Merge(m, src) 428} 429func (m *WriteIndexRequest) XXX_Size() int { 430 return m.Size() 431} 432func (m *WriteIndexRequest) XXX_DiscardUnknown() { 433 xxx_messageInfo_WriteIndexRequest.DiscardUnknown(m) 434} 435 436var xxx_messageInfo_WriteIndexRequest proto.InternalMessageInfo 437 438func (m *WriteIndexRequest) GetWrites() []*IndexEntry { 439 if m != nil { 440 return m.Writes 441 } 442 return nil 443} 444 445type DeleteIndexRequest struct { 446 Deletes []*IndexEntry `protobuf:"bytes,1,rep,name=deletes,proto3" json:"deletes,omitempty"` 447} 448 449func (m *DeleteIndexRequest) Reset() { *m = DeleteIndexRequest{} } 450func (*DeleteIndexRequest) ProtoMessage() {} 451func (*DeleteIndexRequest) Descriptor() ([]byte, []int) { 452 return fileDescriptor_7322c8818cf62b01, []int{9} 453} 454func (m *DeleteIndexRequest) XXX_Unmarshal(b []byte) error { 455 return m.Unmarshal(b) 456} 457func (m *DeleteIndexRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 458 if deterministic { 459 return xxx_messageInfo_DeleteIndexRequest.Marshal(b, m, deterministic) 460 } else { 461 b = b[:cap(b)] 462 n, err := m.MarshalToSizedBuffer(b) 463 if err != nil { 464 return nil, err 465 } 466 return b[:n], nil 467 } 468} 469func (m *DeleteIndexRequest) XXX_Merge(src proto.Message) { 470 xxx_messageInfo_DeleteIndexRequest.Merge(m, src) 471} 472func (m *DeleteIndexRequest) XXX_Size() int { 473 return m.Size() 474} 475func (m *DeleteIndexRequest) XXX_DiscardUnknown() { 476 xxx_messageInfo_DeleteIndexRequest.DiscardUnknown(m) 477} 478 479var xxx_messageInfo_DeleteIndexRequest proto.InternalMessageInfo 480 481func (m *DeleteIndexRequest) GetDeletes() []*IndexEntry { 482 if m != nil { 483 return m.Deletes 484 } 485 return nil 486} 487 488type QueryIndexResponse struct { 489 Rows []*Row `protobuf:"bytes,1,rep,name=rows,proto3" json:"rows,omitempty"` 490} 491 492func (m *QueryIndexResponse) Reset() { *m = QueryIndexResponse{} } 493func (*QueryIndexResponse) ProtoMessage() {} 494func (*QueryIndexResponse) Descriptor() ([]byte, []int) { 495 return fileDescriptor_7322c8818cf62b01, []int{10} 496} 497func (m *QueryIndexResponse) XXX_Unmarshal(b []byte) error { 498 return m.Unmarshal(b) 499} 500func (m *QueryIndexResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 501 if deterministic { 502 return xxx_messageInfo_QueryIndexResponse.Marshal(b, m, deterministic) 503 } else { 504 b = b[:cap(b)] 505 n, err := m.MarshalToSizedBuffer(b) 506 if err != nil { 507 return nil, err 508 } 509 return b[:n], nil 510 } 511} 512func (m *QueryIndexResponse) XXX_Merge(src proto.Message) { 513 xxx_messageInfo_QueryIndexResponse.Merge(m, src) 514} 515func (m *QueryIndexResponse) XXX_Size() int { 516 return m.Size() 517} 518func (m *QueryIndexResponse) XXX_DiscardUnknown() { 519 xxx_messageInfo_QueryIndexResponse.DiscardUnknown(m) 520} 521 522var xxx_messageInfo_QueryIndexResponse proto.InternalMessageInfo 523 524func (m *QueryIndexResponse) GetRows() []*Row { 525 if m != nil { 526 return m.Rows 527 } 528 return nil 529} 530 531type Row struct { 532 RangeValue []byte `protobuf:"bytes,1,opt,name=rangeValue,proto3" json:"rangeValue,omitempty"` 533 Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` 534} 535 536func (m *Row) Reset() { *m = Row{} } 537func (*Row) ProtoMessage() {} 538func (*Row) Descriptor() ([]byte, []int) { 539 return fileDescriptor_7322c8818cf62b01, []int{11} 540} 541func (m *Row) XXX_Unmarshal(b []byte) error { 542 return m.Unmarshal(b) 543} 544func (m *Row) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 545 if deterministic { 546 return xxx_messageInfo_Row.Marshal(b, m, deterministic) 547 } else { 548 b = b[:cap(b)] 549 n, err := m.MarshalToSizedBuffer(b) 550 if err != nil { 551 return nil, err 552 } 553 return b[:n], nil 554 } 555} 556func (m *Row) XXX_Merge(src proto.Message) { 557 xxx_messageInfo_Row.Merge(m, src) 558} 559func (m *Row) XXX_Size() int { 560 return m.Size() 561} 562func (m *Row) XXX_DiscardUnknown() { 563 xxx_messageInfo_Row.DiscardUnknown(m) 564} 565 566var xxx_messageInfo_Row proto.InternalMessageInfo 567 568func (m *Row) GetRangeValue() []byte { 569 if m != nil { 570 return m.RangeValue 571 } 572 return nil 573} 574 575func (m *Row) GetValue() []byte { 576 if m != nil { 577 return m.Value 578 } 579 return nil 580} 581 582type IndexEntry struct { 583 TableName string `protobuf:"bytes,1,opt,name=tableName,proto3" json:"tableName,omitempty"` 584 HashValue string `protobuf:"bytes,2,opt,name=hashValue,proto3" json:"hashValue,omitempty"` 585 RangeValue []byte `protobuf:"bytes,3,opt,name=rangeValue,proto3" json:"rangeValue,omitempty"` 586 Value []byte `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"` 587} 588 589func (m *IndexEntry) Reset() { *m = IndexEntry{} } 590func (*IndexEntry) ProtoMessage() {} 591func (*IndexEntry) Descriptor() ([]byte, []int) { 592 return fileDescriptor_7322c8818cf62b01, []int{12} 593} 594func (m *IndexEntry) XXX_Unmarshal(b []byte) error { 595 return m.Unmarshal(b) 596} 597func (m *IndexEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 598 if deterministic { 599 return xxx_messageInfo_IndexEntry.Marshal(b, m, deterministic) 600 } else { 601 b = b[:cap(b)] 602 n, err := m.MarshalToSizedBuffer(b) 603 if err != nil { 604 return nil, err 605 } 606 return b[:n], nil 607 } 608} 609func (m *IndexEntry) XXX_Merge(src proto.Message) { 610 xxx_messageInfo_IndexEntry.Merge(m, src) 611} 612func (m *IndexEntry) XXX_Size() int { 613 return m.Size() 614} 615func (m *IndexEntry) XXX_DiscardUnknown() { 616 xxx_messageInfo_IndexEntry.DiscardUnknown(m) 617} 618 619var xxx_messageInfo_IndexEntry proto.InternalMessageInfo 620 621func (m *IndexEntry) GetTableName() string { 622 if m != nil { 623 return m.TableName 624 } 625 return "" 626} 627 628func (m *IndexEntry) GetHashValue() string { 629 if m != nil { 630 return m.HashValue 631 } 632 return "" 633} 634 635func (m *IndexEntry) GetRangeValue() []byte { 636 if m != nil { 637 return m.RangeValue 638 } 639 return nil 640} 641 642func (m *IndexEntry) GetValue() []byte { 643 if m != nil { 644 return m.Value 645 } 646 return nil 647} 648 649type QueryIndexRequest struct { 650 TableName string `protobuf:"bytes,1,opt,name=tableName,proto3" json:"tableName,omitempty"` 651 HashValue string `protobuf:"bytes,2,opt,name=hashValue,proto3" json:"hashValue,omitempty"` 652 RangeValuePrefix []byte `protobuf:"bytes,3,opt,name=rangeValuePrefix,proto3" json:"rangeValuePrefix,omitempty"` 653 RangeValueStart []byte `protobuf:"bytes,4,opt,name=rangeValueStart,proto3" json:"rangeValueStart,omitempty"` 654 ValueEqual []byte `protobuf:"bytes,5,opt,name=valueEqual,proto3" json:"valueEqual,omitempty"` 655 Immutable bool `protobuf:"varint,6,opt,name=immutable,proto3" json:"immutable,omitempty"` 656} 657 658func (m *QueryIndexRequest) Reset() { *m = QueryIndexRequest{} } 659func (*QueryIndexRequest) ProtoMessage() {} 660func (*QueryIndexRequest) Descriptor() ([]byte, []int) { 661 return fileDescriptor_7322c8818cf62b01, []int{13} 662} 663func (m *QueryIndexRequest) XXX_Unmarshal(b []byte) error { 664 return m.Unmarshal(b) 665} 666func (m *QueryIndexRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 667 if deterministic { 668 return xxx_messageInfo_QueryIndexRequest.Marshal(b, m, deterministic) 669 } else { 670 b = b[:cap(b)] 671 n, err := m.MarshalToSizedBuffer(b) 672 if err != nil { 673 return nil, err 674 } 675 return b[:n], nil 676 } 677} 678func (m *QueryIndexRequest) XXX_Merge(src proto.Message) { 679 xxx_messageInfo_QueryIndexRequest.Merge(m, src) 680} 681func (m *QueryIndexRequest) XXX_Size() int { 682 return m.Size() 683} 684func (m *QueryIndexRequest) XXX_DiscardUnknown() { 685 xxx_messageInfo_QueryIndexRequest.DiscardUnknown(m) 686} 687 688var xxx_messageInfo_QueryIndexRequest proto.InternalMessageInfo 689 690func (m *QueryIndexRequest) GetTableName() string { 691 if m != nil { 692 return m.TableName 693 } 694 return "" 695} 696 697func (m *QueryIndexRequest) GetHashValue() string { 698 if m != nil { 699 return m.HashValue 700 } 701 return "" 702} 703 704func (m *QueryIndexRequest) GetRangeValuePrefix() []byte { 705 if m != nil { 706 return m.RangeValuePrefix 707 } 708 return nil 709} 710 711func (m *QueryIndexRequest) GetRangeValueStart() []byte { 712 if m != nil { 713 return m.RangeValueStart 714 } 715 return nil 716} 717 718func (m *QueryIndexRequest) GetValueEqual() []byte { 719 if m != nil { 720 return m.ValueEqual 721 } 722 return nil 723} 724 725func (m *QueryIndexRequest) GetImmutable() bool { 726 if m != nil { 727 return m.Immutable 728 } 729 return false 730} 731 732type UpdateTableRequest struct { 733 Current *TableDesc `protobuf:"bytes,1,opt,name=current,proto3" json:"current,omitempty"` 734 Expected *TableDesc `protobuf:"bytes,2,opt,name=expected,proto3" json:"expected,omitempty"` 735} 736 737func (m *UpdateTableRequest) Reset() { *m = UpdateTableRequest{} } 738func (*UpdateTableRequest) ProtoMessage() {} 739func (*UpdateTableRequest) Descriptor() ([]byte, []int) { 740 return fileDescriptor_7322c8818cf62b01, []int{14} 741} 742func (m *UpdateTableRequest) XXX_Unmarshal(b []byte) error { 743 return m.Unmarshal(b) 744} 745func (m *UpdateTableRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 746 if deterministic { 747 return xxx_messageInfo_UpdateTableRequest.Marshal(b, m, deterministic) 748 } else { 749 b = b[:cap(b)] 750 n, err := m.MarshalToSizedBuffer(b) 751 if err != nil { 752 return nil, err 753 } 754 return b[:n], nil 755 } 756} 757func (m *UpdateTableRequest) XXX_Merge(src proto.Message) { 758 xxx_messageInfo_UpdateTableRequest.Merge(m, src) 759} 760func (m *UpdateTableRequest) XXX_Size() int { 761 return m.Size() 762} 763func (m *UpdateTableRequest) XXX_DiscardUnknown() { 764 xxx_messageInfo_UpdateTableRequest.DiscardUnknown(m) 765} 766 767var xxx_messageInfo_UpdateTableRequest proto.InternalMessageInfo 768 769func (m *UpdateTableRequest) GetCurrent() *TableDesc { 770 if m != nil { 771 return m.Current 772 } 773 return nil 774} 775 776func (m *UpdateTableRequest) GetExpected() *TableDesc { 777 if m != nil { 778 return m.Expected 779 } 780 return nil 781} 782 783type DescribeTableResponse struct { 784 Desc *TableDesc `protobuf:"bytes,1,opt,name=desc,proto3" json:"desc,omitempty"` 785 IsActive bool `protobuf:"varint,2,opt,name=isActive,proto3" json:"isActive,omitempty"` 786} 787 788func (m *DescribeTableResponse) Reset() { *m = DescribeTableResponse{} } 789func (*DescribeTableResponse) ProtoMessage() {} 790func (*DescribeTableResponse) Descriptor() ([]byte, []int) { 791 return fileDescriptor_7322c8818cf62b01, []int{15} 792} 793func (m *DescribeTableResponse) XXX_Unmarshal(b []byte) error { 794 return m.Unmarshal(b) 795} 796func (m *DescribeTableResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 797 if deterministic { 798 return xxx_messageInfo_DescribeTableResponse.Marshal(b, m, deterministic) 799 } else { 800 b = b[:cap(b)] 801 n, err := m.MarshalToSizedBuffer(b) 802 if err != nil { 803 return nil, err 804 } 805 return b[:n], nil 806 } 807} 808func (m *DescribeTableResponse) XXX_Merge(src proto.Message) { 809 xxx_messageInfo_DescribeTableResponse.Merge(m, src) 810} 811func (m *DescribeTableResponse) XXX_Size() int { 812 return m.Size() 813} 814func (m *DescribeTableResponse) XXX_DiscardUnknown() { 815 xxx_messageInfo_DescribeTableResponse.DiscardUnknown(m) 816} 817 818var xxx_messageInfo_DescribeTableResponse proto.InternalMessageInfo 819 820func (m *DescribeTableResponse) GetDesc() *TableDesc { 821 if m != nil { 822 return m.Desc 823 } 824 return nil 825} 826 827func (m *DescribeTableResponse) GetIsActive() bool { 828 if m != nil { 829 return m.IsActive 830 } 831 return false 832} 833 834type CreateTableRequest struct { 835 Desc *TableDesc `protobuf:"bytes,1,opt,name=desc,proto3" json:"desc,omitempty"` 836} 837 838func (m *CreateTableRequest) Reset() { *m = CreateTableRequest{} } 839func (*CreateTableRequest) ProtoMessage() {} 840func (*CreateTableRequest) Descriptor() ([]byte, []int) { 841 return fileDescriptor_7322c8818cf62b01, []int{16} 842} 843func (m *CreateTableRequest) XXX_Unmarshal(b []byte) error { 844 return m.Unmarshal(b) 845} 846func (m *CreateTableRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 847 if deterministic { 848 return xxx_messageInfo_CreateTableRequest.Marshal(b, m, deterministic) 849 } else { 850 b = b[:cap(b)] 851 n, err := m.MarshalToSizedBuffer(b) 852 if err != nil { 853 return nil, err 854 } 855 return b[:n], nil 856 } 857} 858func (m *CreateTableRequest) XXX_Merge(src proto.Message) { 859 xxx_messageInfo_CreateTableRequest.Merge(m, src) 860} 861func (m *CreateTableRequest) XXX_Size() int { 862 return m.Size() 863} 864func (m *CreateTableRequest) XXX_DiscardUnknown() { 865 xxx_messageInfo_CreateTableRequest.DiscardUnknown(m) 866} 867 868var xxx_messageInfo_CreateTableRequest proto.InternalMessageInfo 869 870func (m *CreateTableRequest) GetDesc() *TableDesc { 871 if m != nil { 872 return m.Desc 873 } 874 return nil 875} 876 877type TableDesc struct { 878 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` 879 UseOnDemandIOMode bool `protobuf:"varint,2,opt,name=useOnDemandIOMode,proto3" json:"useOnDemandIOMode,omitempty"` 880 ProvisionedRead int64 `protobuf:"varint,3,opt,name=provisionedRead,proto3" json:"provisionedRead,omitempty"` 881 ProvisionedWrite int64 `protobuf:"varint,4,opt,name=provisionedWrite,proto3" json:"provisionedWrite,omitempty"` 882 Tags map[string]string `protobuf:"bytes,5,rep,name=tags,proto3" json:"tags,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` 883} 884 885func (m *TableDesc) Reset() { *m = TableDesc{} } 886func (*TableDesc) ProtoMessage() {} 887func (*TableDesc) Descriptor() ([]byte, []int) { 888 return fileDescriptor_7322c8818cf62b01, []int{17} 889} 890func (m *TableDesc) XXX_Unmarshal(b []byte) error { 891 return m.Unmarshal(b) 892} 893func (m *TableDesc) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 894 if deterministic { 895 return xxx_messageInfo_TableDesc.Marshal(b, m, deterministic) 896 } else { 897 b = b[:cap(b)] 898 n, err := m.MarshalToSizedBuffer(b) 899 if err != nil { 900 return nil, err 901 } 902 return b[:n], nil 903 } 904} 905func (m *TableDesc) XXX_Merge(src proto.Message) { 906 xxx_messageInfo_TableDesc.Merge(m, src) 907} 908func (m *TableDesc) XXX_Size() int { 909 return m.Size() 910} 911func (m *TableDesc) XXX_DiscardUnknown() { 912 xxx_messageInfo_TableDesc.DiscardUnknown(m) 913} 914 915var xxx_messageInfo_TableDesc proto.InternalMessageInfo 916 917func (m *TableDesc) GetName() string { 918 if m != nil { 919 return m.Name 920 } 921 return "" 922} 923 924func (m *TableDesc) GetUseOnDemandIOMode() bool { 925 if m != nil { 926 return m.UseOnDemandIOMode 927 } 928 return false 929} 930 931func (m *TableDesc) GetProvisionedRead() int64 { 932 if m != nil { 933 return m.ProvisionedRead 934 } 935 return 0 936} 937 938func (m *TableDesc) GetProvisionedWrite() int64 { 939 if m != nil { 940 return m.ProvisionedWrite 941 } 942 return 0 943} 944 945func (m *TableDesc) GetTags() map[string]string { 946 if m != nil { 947 return m.Tags 948 } 949 return nil 950} 951 952type ListTablesResponse struct { 953 TableNames []string `protobuf:"bytes,1,rep,name=tableNames,proto3" json:"tableNames,omitempty"` 954} 955 956func (m *ListTablesResponse) Reset() { *m = ListTablesResponse{} } 957func (*ListTablesResponse) ProtoMessage() {} 958func (*ListTablesResponse) Descriptor() ([]byte, []int) { 959 return fileDescriptor_7322c8818cf62b01, []int{18} 960} 961func (m *ListTablesResponse) XXX_Unmarshal(b []byte) error { 962 return m.Unmarshal(b) 963} 964func (m *ListTablesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 965 if deterministic { 966 return xxx_messageInfo_ListTablesResponse.Marshal(b, m, deterministic) 967 } else { 968 b = b[:cap(b)] 969 n, err := m.MarshalToSizedBuffer(b) 970 if err != nil { 971 return nil, err 972 } 973 return b[:n], nil 974 } 975} 976func (m *ListTablesResponse) XXX_Merge(src proto.Message) { 977 xxx_messageInfo_ListTablesResponse.Merge(m, src) 978} 979func (m *ListTablesResponse) XXX_Size() int { 980 return m.Size() 981} 982func (m *ListTablesResponse) XXX_DiscardUnknown() { 983 xxx_messageInfo_ListTablesResponse.DiscardUnknown(m) 984} 985 986var xxx_messageInfo_ListTablesResponse proto.InternalMessageInfo 987 988func (m *ListTablesResponse) GetTableNames() []string { 989 if m != nil { 990 return m.TableNames 991 } 992 return nil 993} 994 995type Labels struct { 996 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` 997 Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` 998} 999 1000func (m *Labels) Reset() { *m = Labels{} } 1001func (*Labels) ProtoMessage() {} 1002func (*Labels) Descriptor() ([]byte, []int) { 1003 return fileDescriptor_7322c8818cf62b01, []int{19} 1004} 1005func (m *Labels) XXX_Unmarshal(b []byte) error { 1006 return m.Unmarshal(b) 1007} 1008func (m *Labels) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1009 if deterministic { 1010 return xxx_messageInfo_Labels.Marshal(b, m, deterministic) 1011 } else { 1012 b = b[:cap(b)] 1013 n, err := m.MarshalToSizedBuffer(b) 1014 if err != nil { 1015 return nil, err 1016 } 1017 return b[:n], nil 1018 } 1019} 1020func (m *Labels) XXX_Merge(src proto.Message) { 1021 xxx_messageInfo_Labels.Merge(m, src) 1022} 1023func (m *Labels) XXX_Size() int { 1024 return m.Size() 1025} 1026func (m *Labels) XXX_DiscardUnknown() { 1027 xxx_messageInfo_Labels.DiscardUnknown(m) 1028} 1029 1030var xxx_messageInfo_Labels proto.InternalMessageInfo 1031 1032func (m *Labels) GetName() string { 1033 if m != nil { 1034 return m.Name 1035 } 1036 return "" 1037} 1038 1039func (m *Labels) GetValue() string { 1040 if m != nil { 1041 return m.Value 1042 } 1043 return "" 1044} 1045 1046func init() { 1047 proto.RegisterType((*PutChunksRequest)(nil), "grpc.PutChunksRequest") 1048 proto.RegisterType((*GetChunksRequest)(nil), "grpc.GetChunksRequest") 1049 proto.RegisterType((*GetChunksResponse)(nil), "grpc.GetChunksResponse") 1050 proto.RegisterType((*Chunk)(nil), "grpc.Chunk") 1051 proto.RegisterType((*ChunkID)(nil), "grpc.ChunkID") 1052 proto.RegisterType((*DeleteTableRequest)(nil), "grpc.DeleteTableRequest") 1053 proto.RegisterType((*DescribeTableRequest)(nil), "grpc.DescribeTableRequest") 1054 proto.RegisterType((*WriteBatch)(nil), "grpc.WriteBatch") 1055 proto.RegisterType((*WriteIndexRequest)(nil), "grpc.WriteIndexRequest") 1056 proto.RegisterType((*DeleteIndexRequest)(nil), "grpc.DeleteIndexRequest") 1057 proto.RegisterType((*QueryIndexResponse)(nil), "grpc.QueryIndexResponse") 1058 proto.RegisterType((*Row)(nil), "grpc.Row") 1059 proto.RegisterType((*IndexEntry)(nil), "grpc.IndexEntry") 1060 proto.RegisterType((*QueryIndexRequest)(nil), "grpc.QueryIndexRequest") 1061 proto.RegisterType((*UpdateTableRequest)(nil), "grpc.UpdateTableRequest") 1062 proto.RegisterType((*DescribeTableResponse)(nil), "grpc.DescribeTableResponse") 1063 proto.RegisterType((*CreateTableRequest)(nil), "grpc.CreateTableRequest") 1064 proto.RegisterType((*TableDesc)(nil), "grpc.TableDesc") 1065 proto.RegisterMapType((map[string]string)(nil), "grpc.TableDesc.TagsEntry") 1066 proto.RegisterType((*ListTablesResponse)(nil), "grpc.ListTablesResponse") 1067 proto.RegisterType((*Labels)(nil), "grpc.Labels") 1068} 1069 1070func init() { proto.RegisterFile("pkg/storage/chunk/grpc/grpc.proto", fileDescriptor_7322c8818cf62b01) } 1071 1072var fileDescriptor_7322c8818cf62b01 = []byte{ 1073 // 938 bytes of a gzipped FileDescriptorProto 1074 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x55, 0xcd, 0x92, 0xdb, 0x44, 1075 0x10, 0xf6, 0xf8, 0x6f, 0x57, 0xed, 0xa4, 0xb2, 0x3b, 0x15, 0x12, 0xe1, 0x80, 0x6a, 0x51, 0x2e, 1076 0x26, 0x80, 0x4d, 0x39, 0x4b, 0x25, 0x90, 0x0a, 0x21, 0x89, 0xb7, 0x60, 0xab, 0x02, 0x49, 0x44, 1077 0x08, 0xdc, 0x28, 0x59, 0xea, 0x78, 0x55, 0x6b, 0x4b, 0x8e, 0x66, 0xb4, 0x3f, 0x17, 0x8a, 0x3b, 1078 0x17, 0x1e, 0x83, 0x47, 0xe1, 0xb8, 0xc7, 0x1c, 0x59, 0xef, 0x85, 0x63, 0x1e, 0x81, 0x9a, 0x91, 1079 0x46, 0x92, 0x25, 0x2b, 0x59, 0x72, 0x51, 0x69, 0xbe, 0xfe, 0xfb, 0x7a, 0x7a, 0xba, 0x1b, 0x3e, 1080 0x9a, 0xef, 0x4f, 0x06, 0x8c, 0x07, 0xa1, 0x3d, 0xc1, 0x81, 0xb3, 0x17, 0xf9, 0xfb, 0x83, 0x49, 1081 0x38, 0x77, 0xe4, 0xa7, 0x3f, 0x0f, 0x03, 0x1e, 0xd0, 0xa6, 0xf8, 0xef, 0x5e, 0x9b, 0x04, 0xc1, 1082 0x64, 0x8a, 0x03, 0x89, 0x8d, 0xa3, 0x17, 0x03, 0x9c, 0xcd, 0xf9, 0x71, 0xac, 0x62, 0xde, 0x82, 1083 0x8d, 0x27, 0x11, 0x7f, 0x28, 0xcc, 0x99, 0x85, 0x2f, 0x23, 0x64, 0x9c, 0x5e, 0x87, 0xb6, 0xf4, 1084 0xc7, 0x74, 0xb2, 0xd5, 0xe8, 0x75, 0x86, 0x9d, 0xbe, 0xf4, 0x29, 0x95, 0xac, 0x44, 0x24, 0x0c, 1085 0xbf, 0xc5, 0x77, 0x31, 0xbc, 0x0d, 0x9b, 0x39, 0x43, 0x36, 0x0f, 0x7c, 0x86, 0xe7, 0xb3, 0x7c, 1086 0x0a, 0x2d, 0x09, 0x50, 0x1d, 0xd6, 0xd0, 0x77, 0x02, 0x17, 0x5d, 0x9d, 0x6c, 0x91, 0xde, 0x05, 1087 0x4b, 0x1d, 0xe9, 0x06, 0x34, 0xf6, 0xf1, 0x58, 0xaf, 0x6f, 0x91, 0x9e, 0x66, 0x89, 0x5f, 0xfa, 1088 0x01, 0x68, 0xdc, 0x1e, 0x4f, 0xf1, 0x07, 0x7b, 0x86, 0x7a, 0x43, 0xe2, 0x19, 0x60, 0x5e, 0x87, 1089 0x35, 0xe9, 0x72, 0x77, 0x24, 0x9c, 0x3a, 0xf1, 0xaf, 0x74, 0xaa, 0x59, 0xea, 0x68, 0x0e, 0x81, 1090 0x8e, 0x70, 0x8a, 0x1c, 0x9f, 0x09, 0x3b, 0x95, 0xec, 0x92, 0x63, 0x52, 0x74, 0xbc, 0x0d, 0x97, 1091 0x47, 0xc8, 0x9c, 0xd0, 0x1b, 0xff, 0x1f, 0xab, 0x31, 0xc0, 0xcf, 0xa1, 0xc7, 0xf1, 0x81, 0xcd, 1092 0x9d, 0x3d, 0xda, 0x83, 0xf6, 0xa1, 0x38, 0xa9, 0x4b, 0xd9, 0x88, 0x2f, 0x65, 0xd7, 0x77, 0xf1, 1093 0x68, 0xc7, 0xe7, 0xe1, 0xb1, 0x95, 0xc8, 0xe9, 0x0d, 0x58, 0x73, 0x25, 0x43, 0xa6, 0xd7, 0x2b, 1094 0x54, 0x95, 0x82, 0x79, 0x17, 0x36, 0x65, 0x0c, 0x29, 0x53, 0xb4, 0xce, 0x1d, 0xca, 0xfc, 0x46, 1095 0x5d, 0xc6, 0x92, 0x7d, 0x8e, 0x00, 0x79, 0x1b, 0x81, 0x9b, 0x40, 0x9f, 0x46, 0x18, 0x1e, 0x27, 1096 0x0e, 0x92, 0x17, 0xf0, 0x21, 0x34, 0xc3, 0xe0, 0x50, 0x99, 0x6b, 0xb1, 0xb9, 0x15, 0x1c, 0x5a, 1097 0x12, 0x36, 0xef, 0x40, 0xc3, 0x0a, 0x0e, 0xa9, 0x01, 0x10, 0xda, 0xfe, 0x04, 0x9f, 0xdb, 0xd3, 1098 0x08, 0x93, 0xe2, 0xe7, 0x10, 0x7a, 0x19, 0x5a, 0x07, 0x52, 0x54, 0x97, 0xa2, 0xf8, 0x60, 0xfe, 1099 0x06, 0x90, 0x11, 0x79, 0x73, 0x09, 0x84, 0x74, 0xcf, 0x66, 0x7b, 0xcf, 0x53, 0x2f, 0x9a, 0x95, 1100 0x01, 0x85, 0xf8, 0x8d, 0xea, 0xf8, 0xcd, 0x7c, 0xfc, 0x33, 0x02, 0x9b, 0xf9, 0x94, 0xcf, 0xf1, 1101 0x14, 0xde, 0xc2, 0xe3, 0x06, 0x6c, 0x64, 0x51, 0x9f, 0x84, 0xf8, 0xc2, 0x3b, 0x4a, 0xd8, 0x94, 1102 0x70, 0xda, 0x83, 0x4b, 0x19, 0xf6, 0x23, 0xb7, 0x43, 0x9e, 0xb0, 0x2b, 0xc2, 0x22, 0x3b, 0x49, 1103 0x78, 0xe7, 0x65, 0x64, 0x4f, 0xf5, 0x56, 0x9c, 0x5d, 0x86, 0x08, 0x4e, 0xde, 0x6c, 0x16, 0x49, 1104 0x92, 0x7a, 0x7b, 0x8b, 0xf4, 0xd6, 0xad, 0x0c, 0x30, 0xa7, 0x40, 0x7f, 0x9a, 0xbb, 0x76, 0xa1, 1105 0x4d, 0x3e, 0x86, 0x35, 0x27, 0x0a, 0x43, 0xf4, 0xb9, 0xcc, 0xb1, 0x33, 0xbc, 0x14, 0x97, 0x56, 1106 0x2a, 0x89, 0x16, 0xb1, 0x94, 0x9c, 0x7e, 0x02, 0xeb, 0x78, 0x34, 0x47, 0x87, 0xa3, 0x2b, 0x33, 1107 0x5e, 0xa1, 0x9b, 0x2a, 0x98, 0xbf, 0xc0, 0x7b, 0x85, 0x06, 0x4b, 0x47, 0x49, 0xd3, 0x45, 0xe6, 1108 0x54, 0x45, 0x93, 0x42, 0xda, 0x85, 0x75, 0x8f, 0xdd, 0x77, 0xb8, 0x77, 0x10, 0x5f, 0xee, 0xba, 1109 0x95, 0x9e, 0xcd, 0x2f, 0x81, 0x3e, 0x0c, 0xb1, 0x98, 0xc7, 0x79, 0xdc, 0x9a, 0x7f, 0xd4, 0x41, 1110 0x4b, 0x31, 0x4a, 0xa1, 0xe9, 0x67, 0xb5, 0x95, 0xff, 0xf4, 0x53, 0xd8, 0x8c, 0x18, 0x3e, 0xf6, 1111 0x47, 0x38, 0xb3, 0x7d, 0x77, 0xf7, 0xf1, 0xf7, 0x81, 0xab, 0x18, 0x94, 0x05, 0xa2, 0x74, 0xf3, 1112 0x30, 0x38, 0xf0, 0x98, 0x17, 0xf8, 0xe8, 0x5a, 0x68, 0xbb, 0xb2, 0xca, 0x0d, 0xab, 0x08, 0x8b, 1113 0x07, 0x91, 0x83, 0x64, 0x83, 0xcb, 0x2a, 0x37, 0xac, 0x12, 0x4e, 0x3f, 0x83, 0x26, 0xb7, 0x27, 1114 0x4c, 0x6f, 0xc9, 0x56, 0x7b, 0xbf, 0x90, 0x4a, 0xff, 0x99, 0x3d, 0x61, 0x71, 0xcb, 0x4a, 0xb5, 1115 0xee, 0x2d, 0x91, 0x53, 0x02, 0xa9, 0x01, 0x4b, 0xb2, 0x01, 0xbb, 0xd4, 0x72, 0x5a, 0xf2, 0xe4, 1116 0xbf, 0xaa, 0xdf, 0x26, 0xe6, 0x36, 0xd0, 0x47, 0x1e, 0xe3, 0xd2, 0x73, 0x36, 0xea, 0x0d, 0x80, 1117 0xf4, 0x95, 0xc7, 0xed, 0xae, 0x59, 0x39, 0xc4, 0x1c, 0x42, 0xfb, 0x91, 0x3d, 0xc6, 0x29, 0x5b, 1118 0x79, 0x7f, 0x2b, 0xa3, 0x0d, 0x4f, 0x5a, 0x00, 0x22, 0x8b, 0x5f, 0xc5, 0x3e, 0x44, 0x7a, 0x37, 1119 0x19, 0xa3, 0xb2, 0xdd, 0xe8, 0xd5, 0x38, 0xc1, 0xd2, 0xd0, 0xeb, 0x5e, 0xe9, 0xc7, 0x9b, 0xb1, 1120 0xaf, 0x36, 0x63, 0x7f, 0x47, 0x6c, 0x46, 0x7a, 0x1f, 0x20, 0xeb, 0x56, 0x65, 0x5e, 0xea, 0xdf, 1121 0xae, 0x5e, 0x16, 0xc4, 0x29, 0x7e, 0x4e, 0xe8, 0x3d, 0xe8, 0xe4, 0xa6, 0x24, 0x4d, 0x54, 0xcb, 1122 0x83, 0xb3, 0x92, 0xc3, 0x1d, 0xd0, 0xd2, 0xbd, 0x4c, 0xaf, 0xc4, 0xe6, 0xc5, 0x45, 0x5d, 0x69, 1123 0xfc, 0x35, 0x68, 0xe9, 0x8a, 0x55, 0xc6, 0xc5, 0x65, 0xdd, 0xbd, 0x5a, 0xc2, 0x53, 0xf6, 0x5f, 1124 0xc0, 0x85, 0x98, 0x6a, 0xe2, 0xe2, 0x62, 0x6e, 0x1b, 0xef, 0x8e, 0xde, 0x10, 0x16, 0xb2, 0x7a, 1125 0xd3, 0x0a, 0x2d, 0x75, 0x6d, 0x2b, 0x5e, 0xc6, 0x3d, 0xe8, 0xe4, 0x1a, 0x4f, 0x5d, 0x5a, 0xb9, 1126 0x17, 0x2b, 0x09, 0xa4, 0xb7, 0xbe, 0xe4, 0xa0, 0xbc, 0xbb, 0x2b, 0x1d, 0x7c, 0x07, 0x17, 0x97, 1127 0x86, 0x0a, 0xed, 0x2a, 0x17, 0xe5, 0x55, 0xde, 0xbd, 0xb6, 0x52, 0x96, 0xe5, 0x92, 0x1b, 0x86, 1128 0x8a, 0x4a, 0x79, 0x3e, 0x56, 0x51, 0x79, 0xb0, 0x7d, 0x72, 0x6a, 0xd4, 0x5e, 0x9d, 0x1a, 0xb5, 1129 0xd7, 0xa7, 0x06, 0xf9, 0x7d, 0x61, 0x90, 0xbf, 0x16, 0x06, 0xf9, 0x7b, 0x61, 0x90, 0x93, 0x85, 1130 0x41, 0xfe, 0x59, 0x18, 0xe4, 0xdf, 0x85, 0x51, 0x7b, 0xbd, 0x30, 0xc8, 0x9f, 0x67, 0x46, 0xed, 1131 0xe4, 0xcc, 0xa8, 0xbd, 0x3a, 0x33, 0x6a, 0xe3, 0xb6, 0xf4, 0x72, 0xf3, 0xbf, 0x00, 0x00, 0x00, 1132 0xff, 0xff, 0xc0, 0x0f, 0xab, 0x83, 0x1d, 0x0a, 0x00, 0x00, 1133} 1134 1135func (this *PutChunksRequest) Equal(that interface{}) bool { 1136 if that == nil { 1137 return this == nil 1138 } 1139 1140 that1, ok := that.(*PutChunksRequest) 1141 if !ok { 1142 that2, ok := that.(PutChunksRequest) 1143 if ok { 1144 that1 = &that2 1145 } else { 1146 return false 1147 } 1148 } 1149 if that1 == nil { 1150 return this == nil 1151 } else if this == nil { 1152 return false 1153 } 1154 if len(this.Chunks) != len(that1.Chunks) { 1155 return false 1156 } 1157 for i := range this.Chunks { 1158 if !this.Chunks[i].Equal(that1.Chunks[i]) { 1159 return false 1160 } 1161 } 1162 return true 1163} 1164func (this *GetChunksRequest) Equal(that interface{}) bool { 1165 if that == nil { 1166 return this == nil 1167 } 1168 1169 that1, ok := that.(*GetChunksRequest) 1170 if !ok { 1171 that2, ok := that.(GetChunksRequest) 1172 if ok { 1173 that1 = &that2 1174 } else { 1175 return false 1176 } 1177 } 1178 if that1 == nil { 1179 return this == nil 1180 } else if this == nil { 1181 return false 1182 } 1183 if len(this.Chunks) != len(that1.Chunks) { 1184 return false 1185 } 1186 for i := range this.Chunks { 1187 if !this.Chunks[i].Equal(that1.Chunks[i]) { 1188 return false 1189 } 1190 } 1191 return true 1192} 1193func (this *GetChunksResponse) Equal(that interface{}) bool { 1194 if that == nil { 1195 return this == nil 1196 } 1197 1198 that1, ok := that.(*GetChunksResponse) 1199 if !ok { 1200 that2, ok := that.(GetChunksResponse) 1201 if ok { 1202 that1 = &that2 1203 } else { 1204 return false 1205 } 1206 } 1207 if that1 == nil { 1208 return this == nil 1209 } else if this == nil { 1210 return false 1211 } 1212 if len(this.Chunks) != len(that1.Chunks) { 1213 return false 1214 } 1215 for i := range this.Chunks { 1216 if !this.Chunks[i].Equal(that1.Chunks[i]) { 1217 return false 1218 } 1219 } 1220 return true 1221} 1222func (this *Chunk) Equal(that interface{}) bool { 1223 if that == nil { 1224 return this == nil 1225 } 1226 1227 that1, ok := that.(*Chunk) 1228 if !ok { 1229 that2, ok := that.(Chunk) 1230 if ok { 1231 that1 = &that2 1232 } else { 1233 return false 1234 } 1235 } 1236 if that1 == nil { 1237 return this == nil 1238 } else if this == nil { 1239 return false 1240 } 1241 if !bytes.Equal(this.Encoded, that1.Encoded) { 1242 return false 1243 } 1244 if this.Key != that1.Key { 1245 return false 1246 } 1247 if this.TableName != that1.TableName { 1248 return false 1249 } 1250 return true 1251} 1252func (this *ChunkID) Equal(that interface{}) bool { 1253 if that == nil { 1254 return this == nil 1255 } 1256 1257 that1, ok := that.(*ChunkID) 1258 if !ok { 1259 that2, ok := that.(ChunkID) 1260 if ok { 1261 that1 = &that2 1262 } else { 1263 return false 1264 } 1265 } 1266 if that1 == nil { 1267 return this == nil 1268 } else if this == nil { 1269 return false 1270 } 1271 if this.ChunkID != that1.ChunkID { 1272 return false 1273 } 1274 return true 1275} 1276func (this *DeleteTableRequest) Equal(that interface{}) bool { 1277 if that == nil { 1278 return this == nil 1279 } 1280 1281 that1, ok := that.(*DeleteTableRequest) 1282 if !ok { 1283 that2, ok := that.(DeleteTableRequest) 1284 if ok { 1285 that1 = &that2 1286 } else { 1287 return false 1288 } 1289 } 1290 if that1 == nil { 1291 return this == nil 1292 } else if this == nil { 1293 return false 1294 } 1295 if this.TableName != that1.TableName { 1296 return false 1297 } 1298 return true 1299} 1300func (this *DescribeTableRequest) Equal(that interface{}) bool { 1301 if that == nil { 1302 return this == nil 1303 } 1304 1305 that1, ok := that.(*DescribeTableRequest) 1306 if !ok { 1307 that2, ok := that.(DescribeTableRequest) 1308 if ok { 1309 that1 = &that2 1310 } else { 1311 return false 1312 } 1313 } 1314 if that1 == nil { 1315 return this == nil 1316 } else if this == nil { 1317 return false 1318 } 1319 if this.TableName != that1.TableName { 1320 return false 1321 } 1322 return true 1323} 1324func (this *WriteBatch) Equal(that interface{}) bool { 1325 if that == nil { 1326 return this == nil 1327 } 1328 1329 that1, ok := that.(*WriteBatch) 1330 if !ok { 1331 that2, ok := that.(WriteBatch) 1332 if ok { 1333 that1 = &that2 1334 } else { 1335 return false 1336 } 1337 } 1338 if that1 == nil { 1339 return this == nil 1340 } else if this == nil { 1341 return false 1342 } 1343 if len(this.Writes) != len(that1.Writes) { 1344 return false 1345 } 1346 for i := range this.Writes { 1347 if !this.Writes[i].Equal(that1.Writes[i]) { 1348 return false 1349 } 1350 } 1351 if len(this.Deletes) != len(that1.Deletes) { 1352 return false 1353 } 1354 for i := range this.Deletes { 1355 if !this.Deletes[i].Equal(that1.Deletes[i]) { 1356 return false 1357 } 1358 } 1359 return true 1360} 1361func (this *WriteIndexRequest) Equal(that interface{}) bool { 1362 if that == nil { 1363 return this == nil 1364 } 1365 1366 that1, ok := that.(*WriteIndexRequest) 1367 if !ok { 1368 that2, ok := that.(WriteIndexRequest) 1369 if ok { 1370 that1 = &that2 1371 } else { 1372 return false 1373 } 1374 } 1375 if that1 == nil { 1376 return this == nil 1377 } else if this == nil { 1378 return false 1379 } 1380 if len(this.Writes) != len(that1.Writes) { 1381 return false 1382 } 1383 for i := range this.Writes { 1384 if !this.Writes[i].Equal(that1.Writes[i]) { 1385 return false 1386 } 1387 } 1388 return true 1389} 1390func (this *DeleteIndexRequest) Equal(that interface{}) bool { 1391 if that == nil { 1392 return this == nil 1393 } 1394 1395 that1, ok := that.(*DeleteIndexRequest) 1396 if !ok { 1397 that2, ok := that.(DeleteIndexRequest) 1398 if ok { 1399 that1 = &that2 1400 } else { 1401 return false 1402 } 1403 } 1404 if that1 == nil { 1405 return this == nil 1406 } else if this == nil { 1407 return false 1408 } 1409 if len(this.Deletes) != len(that1.Deletes) { 1410 return false 1411 } 1412 for i := range this.Deletes { 1413 if !this.Deletes[i].Equal(that1.Deletes[i]) { 1414 return false 1415 } 1416 } 1417 return true 1418} 1419func (this *QueryIndexResponse) Equal(that interface{}) bool { 1420 if that == nil { 1421 return this == nil 1422 } 1423 1424 that1, ok := that.(*QueryIndexResponse) 1425 if !ok { 1426 that2, ok := that.(QueryIndexResponse) 1427 if ok { 1428 that1 = &that2 1429 } else { 1430 return false 1431 } 1432 } 1433 if that1 == nil { 1434 return this == nil 1435 } else if this == nil { 1436 return false 1437 } 1438 if len(this.Rows) != len(that1.Rows) { 1439 return false 1440 } 1441 for i := range this.Rows { 1442 if !this.Rows[i].Equal(that1.Rows[i]) { 1443 return false 1444 } 1445 } 1446 return true 1447} 1448func (this *Row) Equal(that interface{}) bool { 1449 if that == nil { 1450 return this == nil 1451 } 1452 1453 that1, ok := that.(*Row) 1454 if !ok { 1455 that2, ok := that.(Row) 1456 if ok { 1457 that1 = &that2 1458 } else { 1459 return false 1460 } 1461 } 1462 if that1 == nil { 1463 return this == nil 1464 } else if this == nil { 1465 return false 1466 } 1467 if !bytes.Equal(this.RangeValue, that1.RangeValue) { 1468 return false 1469 } 1470 if !bytes.Equal(this.Value, that1.Value) { 1471 return false 1472 } 1473 return true 1474} 1475func (this *IndexEntry) Equal(that interface{}) bool { 1476 if that == nil { 1477 return this == nil 1478 } 1479 1480 that1, ok := that.(*IndexEntry) 1481 if !ok { 1482 that2, ok := that.(IndexEntry) 1483 if ok { 1484 that1 = &that2 1485 } else { 1486 return false 1487 } 1488 } 1489 if that1 == nil { 1490 return this == nil 1491 } else if this == nil { 1492 return false 1493 } 1494 if this.TableName != that1.TableName { 1495 return false 1496 } 1497 if this.HashValue != that1.HashValue { 1498 return false 1499 } 1500 if !bytes.Equal(this.RangeValue, that1.RangeValue) { 1501 return false 1502 } 1503 if !bytes.Equal(this.Value, that1.Value) { 1504 return false 1505 } 1506 return true 1507} 1508func (this *QueryIndexRequest) Equal(that interface{}) bool { 1509 if that == nil { 1510 return this == nil 1511 } 1512 1513 that1, ok := that.(*QueryIndexRequest) 1514 if !ok { 1515 that2, ok := that.(QueryIndexRequest) 1516 if ok { 1517 that1 = &that2 1518 } else { 1519 return false 1520 } 1521 } 1522 if that1 == nil { 1523 return this == nil 1524 } else if this == nil { 1525 return false 1526 } 1527 if this.TableName != that1.TableName { 1528 return false 1529 } 1530 if this.HashValue != that1.HashValue { 1531 return false 1532 } 1533 if !bytes.Equal(this.RangeValuePrefix, that1.RangeValuePrefix) { 1534 return false 1535 } 1536 if !bytes.Equal(this.RangeValueStart, that1.RangeValueStart) { 1537 return false 1538 } 1539 if !bytes.Equal(this.ValueEqual, that1.ValueEqual) { 1540 return false 1541 } 1542 if this.Immutable != that1.Immutable { 1543 return false 1544 } 1545 return true 1546} 1547func (this *UpdateTableRequest) Equal(that interface{}) bool { 1548 if that == nil { 1549 return this == nil 1550 } 1551 1552 that1, ok := that.(*UpdateTableRequest) 1553 if !ok { 1554 that2, ok := that.(UpdateTableRequest) 1555 if ok { 1556 that1 = &that2 1557 } else { 1558 return false 1559 } 1560 } 1561 if that1 == nil { 1562 return this == nil 1563 } else if this == nil { 1564 return false 1565 } 1566 if !this.Current.Equal(that1.Current) { 1567 return false 1568 } 1569 if !this.Expected.Equal(that1.Expected) { 1570 return false 1571 } 1572 return true 1573} 1574func (this *DescribeTableResponse) Equal(that interface{}) bool { 1575 if that == nil { 1576 return this == nil 1577 } 1578 1579 that1, ok := that.(*DescribeTableResponse) 1580 if !ok { 1581 that2, ok := that.(DescribeTableResponse) 1582 if ok { 1583 that1 = &that2 1584 } else { 1585 return false 1586 } 1587 } 1588 if that1 == nil { 1589 return this == nil 1590 } else if this == nil { 1591 return false 1592 } 1593 if !this.Desc.Equal(that1.Desc) { 1594 return false 1595 } 1596 if this.IsActive != that1.IsActive { 1597 return false 1598 } 1599 return true 1600} 1601func (this *CreateTableRequest) Equal(that interface{}) bool { 1602 if that == nil { 1603 return this == nil 1604 } 1605 1606 that1, ok := that.(*CreateTableRequest) 1607 if !ok { 1608 that2, ok := that.(CreateTableRequest) 1609 if ok { 1610 that1 = &that2 1611 } else { 1612 return false 1613 } 1614 } 1615 if that1 == nil { 1616 return this == nil 1617 } else if this == nil { 1618 return false 1619 } 1620 if !this.Desc.Equal(that1.Desc) { 1621 return false 1622 } 1623 return true 1624} 1625func (this *TableDesc) Equal(that interface{}) bool { 1626 if that == nil { 1627 return this == nil 1628 } 1629 1630 that1, ok := that.(*TableDesc) 1631 if !ok { 1632 that2, ok := that.(TableDesc) 1633 if ok { 1634 that1 = &that2 1635 } else { 1636 return false 1637 } 1638 } 1639 if that1 == nil { 1640 return this == nil 1641 } else if this == nil { 1642 return false 1643 } 1644 if this.Name != that1.Name { 1645 return false 1646 } 1647 if this.UseOnDemandIOMode != that1.UseOnDemandIOMode { 1648 return false 1649 } 1650 if this.ProvisionedRead != that1.ProvisionedRead { 1651 return false 1652 } 1653 if this.ProvisionedWrite != that1.ProvisionedWrite { 1654 return false 1655 } 1656 if len(this.Tags) != len(that1.Tags) { 1657 return false 1658 } 1659 for i := range this.Tags { 1660 if this.Tags[i] != that1.Tags[i] { 1661 return false 1662 } 1663 } 1664 return true 1665} 1666func (this *ListTablesResponse) Equal(that interface{}) bool { 1667 if that == nil { 1668 return this == nil 1669 } 1670 1671 that1, ok := that.(*ListTablesResponse) 1672 if !ok { 1673 that2, ok := that.(ListTablesResponse) 1674 if ok { 1675 that1 = &that2 1676 } else { 1677 return false 1678 } 1679 } 1680 if that1 == nil { 1681 return this == nil 1682 } else if this == nil { 1683 return false 1684 } 1685 if len(this.TableNames) != len(that1.TableNames) { 1686 return false 1687 } 1688 for i := range this.TableNames { 1689 if this.TableNames[i] != that1.TableNames[i] { 1690 return false 1691 } 1692 } 1693 return true 1694} 1695func (this *Labels) Equal(that interface{}) bool { 1696 if that == nil { 1697 return this == nil 1698 } 1699 1700 that1, ok := that.(*Labels) 1701 if !ok { 1702 that2, ok := that.(Labels) 1703 if ok { 1704 that1 = &that2 1705 } else { 1706 return false 1707 } 1708 } 1709 if that1 == nil { 1710 return this == nil 1711 } else if this == nil { 1712 return false 1713 } 1714 if this.Name != that1.Name { 1715 return false 1716 } 1717 if this.Value != that1.Value { 1718 return false 1719 } 1720 return true 1721} 1722func (this *PutChunksRequest) GoString() string { 1723 if this == nil { 1724 return "nil" 1725 } 1726 s := make([]string, 0, 5) 1727 s = append(s, "&grpc.PutChunksRequest{") 1728 if this.Chunks != nil { 1729 s = append(s, "Chunks: "+fmt.Sprintf("%#v", this.Chunks)+",\n") 1730 } 1731 s = append(s, "}") 1732 return strings.Join(s, "") 1733} 1734func (this *GetChunksRequest) GoString() string { 1735 if this == nil { 1736 return "nil" 1737 } 1738 s := make([]string, 0, 5) 1739 s = append(s, "&grpc.GetChunksRequest{") 1740 if this.Chunks != nil { 1741 s = append(s, "Chunks: "+fmt.Sprintf("%#v", this.Chunks)+",\n") 1742 } 1743 s = append(s, "}") 1744 return strings.Join(s, "") 1745} 1746func (this *GetChunksResponse) GoString() string { 1747 if this == nil { 1748 return "nil" 1749 } 1750 s := make([]string, 0, 5) 1751 s = append(s, "&grpc.GetChunksResponse{") 1752 if this.Chunks != nil { 1753 s = append(s, "Chunks: "+fmt.Sprintf("%#v", this.Chunks)+",\n") 1754 } 1755 s = append(s, "}") 1756 return strings.Join(s, "") 1757} 1758func (this *Chunk) GoString() string { 1759 if this == nil { 1760 return "nil" 1761 } 1762 s := make([]string, 0, 7) 1763 s = append(s, "&grpc.Chunk{") 1764 s = append(s, "Encoded: "+fmt.Sprintf("%#v", this.Encoded)+",\n") 1765 s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n") 1766 s = append(s, "TableName: "+fmt.Sprintf("%#v", this.TableName)+",\n") 1767 s = append(s, "}") 1768 return strings.Join(s, "") 1769} 1770func (this *ChunkID) GoString() string { 1771 if this == nil { 1772 return "nil" 1773 } 1774 s := make([]string, 0, 5) 1775 s = append(s, "&grpc.ChunkID{") 1776 s = append(s, "ChunkID: "+fmt.Sprintf("%#v", this.ChunkID)+",\n") 1777 s = append(s, "}") 1778 return strings.Join(s, "") 1779} 1780func (this *DeleteTableRequest) GoString() string { 1781 if this == nil { 1782 return "nil" 1783 } 1784 s := make([]string, 0, 5) 1785 s = append(s, "&grpc.DeleteTableRequest{") 1786 s = append(s, "TableName: "+fmt.Sprintf("%#v", this.TableName)+",\n") 1787 s = append(s, "}") 1788 return strings.Join(s, "") 1789} 1790func (this *DescribeTableRequest) GoString() string { 1791 if this == nil { 1792 return "nil" 1793 } 1794 s := make([]string, 0, 5) 1795 s = append(s, "&grpc.DescribeTableRequest{") 1796 s = append(s, "TableName: "+fmt.Sprintf("%#v", this.TableName)+",\n") 1797 s = append(s, "}") 1798 return strings.Join(s, "") 1799} 1800func (this *WriteBatch) GoString() string { 1801 if this == nil { 1802 return "nil" 1803 } 1804 s := make([]string, 0, 6) 1805 s = append(s, "&grpc.WriteBatch{") 1806 if this.Writes != nil { 1807 s = append(s, "Writes: "+fmt.Sprintf("%#v", this.Writes)+",\n") 1808 } 1809 if this.Deletes != nil { 1810 s = append(s, "Deletes: "+fmt.Sprintf("%#v", this.Deletes)+",\n") 1811 } 1812 s = append(s, "}") 1813 return strings.Join(s, "") 1814} 1815func (this *WriteIndexRequest) GoString() string { 1816 if this == nil { 1817 return "nil" 1818 } 1819 s := make([]string, 0, 5) 1820 s = append(s, "&grpc.WriteIndexRequest{") 1821 if this.Writes != nil { 1822 s = append(s, "Writes: "+fmt.Sprintf("%#v", this.Writes)+",\n") 1823 } 1824 s = append(s, "}") 1825 return strings.Join(s, "") 1826} 1827func (this *DeleteIndexRequest) GoString() string { 1828 if this == nil { 1829 return "nil" 1830 } 1831 s := make([]string, 0, 5) 1832 s = append(s, "&grpc.DeleteIndexRequest{") 1833 if this.Deletes != nil { 1834 s = append(s, "Deletes: "+fmt.Sprintf("%#v", this.Deletes)+",\n") 1835 } 1836 s = append(s, "}") 1837 return strings.Join(s, "") 1838} 1839func (this *QueryIndexResponse) GoString() string { 1840 if this == nil { 1841 return "nil" 1842 } 1843 s := make([]string, 0, 5) 1844 s = append(s, "&grpc.QueryIndexResponse{") 1845 if this.Rows != nil { 1846 s = append(s, "Rows: "+fmt.Sprintf("%#v", this.Rows)+",\n") 1847 } 1848 s = append(s, "}") 1849 return strings.Join(s, "") 1850} 1851func (this *Row) GoString() string { 1852 if this == nil { 1853 return "nil" 1854 } 1855 s := make([]string, 0, 6) 1856 s = append(s, "&grpc.Row{") 1857 s = append(s, "RangeValue: "+fmt.Sprintf("%#v", this.RangeValue)+",\n") 1858 s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") 1859 s = append(s, "}") 1860 return strings.Join(s, "") 1861} 1862func (this *IndexEntry) GoString() string { 1863 if this == nil { 1864 return "nil" 1865 } 1866 s := make([]string, 0, 8) 1867 s = append(s, "&grpc.IndexEntry{") 1868 s = append(s, "TableName: "+fmt.Sprintf("%#v", this.TableName)+",\n") 1869 s = append(s, "HashValue: "+fmt.Sprintf("%#v", this.HashValue)+",\n") 1870 s = append(s, "RangeValue: "+fmt.Sprintf("%#v", this.RangeValue)+",\n") 1871 s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") 1872 s = append(s, "}") 1873 return strings.Join(s, "") 1874} 1875func (this *QueryIndexRequest) GoString() string { 1876 if this == nil { 1877 return "nil" 1878 } 1879 s := make([]string, 0, 10) 1880 s = append(s, "&grpc.QueryIndexRequest{") 1881 s = append(s, "TableName: "+fmt.Sprintf("%#v", this.TableName)+",\n") 1882 s = append(s, "HashValue: "+fmt.Sprintf("%#v", this.HashValue)+",\n") 1883 s = append(s, "RangeValuePrefix: "+fmt.Sprintf("%#v", this.RangeValuePrefix)+",\n") 1884 s = append(s, "RangeValueStart: "+fmt.Sprintf("%#v", this.RangeValueStart)+",\n") 1885 s = append(s, "ValueEqual: "+fmt.Sprintf("%#v", this.ValueEqual)+",\n") 1886 s = append(s, "Immutable: "+fmt.Sprintf("%#v", this.Immutable)+",\n") 1887 s = append(s, "}") 1888 return strings.Join(s, "") 1889} 1890func (this *UpdateTableRequest) GoString() string { 1891 if this == nil { 1892 return "nil" 1893 } 1894 s := make([]string, 0, 6) 1895 s = append(s, "&grpc.UpdateTableRequest{") 1896 if this.Current != nil { 1897 s = append(s, "Current: "+fmt.Sprintf("%#v", this.Current)+",\n") 1898 } 1899 if this.Expected != nil { 1900 s = append(s, "Expected: "+fmt.Sprintf("%#v", this.Expected)+",\n") 1901 } 1902 s = append(s, "}") 1903 return strings.Join(s, "") 1904} 1905func (this *DescribeTableResponse) GoString() string { 1906 if this == nil { 1907 return "nil" 1908 } 1909 s := make([]string, 0, 6) 1910 s = append(s, "&grpc.DescribeTableResponse{") 1911 if this.Desc != nil { 1912 s = append(s, "Desc: "+fmt.Sprintf("%#v", this.Desc)+",\n") 1913 } 1914 s = append(s, "IsActive: "+fmt.Sprintf("%#v", this.IsActive)+",\n") 1915 s = append(s, "}") 1916 return strings.Join(s, "") 1917} 1918func (this *CreateTableRequest) GoString() string { 1919 if this == nil { 1920 return "nil" 1921 } 1922 s := make([]string, 0, 5) 1923 s = append(s, "&grpc.CreateTableRequest{") 1924 if this.Desc != nil { 1925 s = append(s, "Desc: "+fmt.Sprintf("%#v", this.Desc)+",\n") 1926 } 1927 s = append(s, "}") 1928 return strings.Join(s, "") 1929} 1930func (this *TableDesc) GoString() string { 1931 if this == nil { 1932 return "nil" 1933 } 1934 s := make([]string, 0, 9) 1935 s = append(s, "&grpc.TableDesc{") 1936 s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n") 1937 s = append(s, "UseOnDemandIOMode: "+fmt.Sprintf("%#v", this.UseOnDemandIOMode)+",\n") 1938 s = append(s, "ProvisionedRead: "+fmt.Sprintf("%#v", this.ProvisionedRead)+",\n") 1939 s = append(s, "ProvisionedWrite: "+fmt.Sprintf("%#v", this.ProvisionedWrite)+",\n") 1940 keysForTags := make([]string, 0, len(this.Tags)) 1941 for k, _ := range this.Tags { 1942 keysForTags = append(keysForTags, k) 1943 } 1944 github_com_gogo_protobuf_sortkeys.Strings(keysForTags) 1945 mapStringForTags := "map[string]string{" 1946 for _, k := range keysForTags { 1947 mapStringForTags += fmt.Sprintf("%#v: %#v,", k, this.Tags[k]) 1948 } 1949 mapStringForTags += "}" 1950 if this.Tags != nil { 1951 s = append(s, "Tags: "+mapStringForTags+",\n") 1952 } 1953 s = append(s, "}") 1954 return strings.Join(s, "") 1955} 1956func (this *ListTablesResponse) GoString() string { 1957 if this == nil { 1958 return "nil" 1959 } 1960 s := make([]string, 0, 5) 1961 s = append(s, "&grpc.ListTablesResponse{") 1962 s = append(s, "TableNames: "+fmt.Sprintf("%#v", this.TableNames)+",\n") 1963 s = append(s, "}") 1964 return strings.Join(s, "") 1965} 1966func (this *Labels) GoString() string { 1967 if this == nil { 1968 return "nil" 1969 } 1970 s := make([]string, 0, 6) 1971 s = append(s, "&grpc.Labels{") 1972 s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n") 1973 s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") 1974 s = append(s, "}") 1975 return strings.Join(s, "") 1976} 1977func valueToGoStringGrpc(v interface{}, typ string) string { 1978 rv := reflect.ValueOf(v) 1979 if rv.IsNil() { 1980 return "nil" 1981 } 1982 pv := reflect.Indirect(rv).Interface() 1983 return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) 1984} 1985 1986// Reference imports to suppress errors if they are not otherwise used. 1987var _ context.Context 1988var _ grpc.ClientConn 1989 1990// This is a compile-time assertion to ensure that this generated file 1991// is compatible with the grpc package it is being compiled against. 1992const _ = grpc.SupportPackageIsVersion4 1993 1994// GrpcStoreClient is the client API for GrpcStore service. 1995// 1996// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. 1997type GrpcStoreClient interface { 1998 /// WriteIndex writes batch of indexes to the index tables. 1999 WriteIndex(ctx context.Context, in *WriteIndexRequest, opts ...grpc.CallOption) (*empty.Empty, error) 2000 /// QueryIndex reads the indexes required for given query & sends back the batch of rows 2001 /// in rpc streams 2002 QueryIndex(ctx context.Context, in *QueryIndexRequest, opts ...grpc.CallOption) (GrpcStore_QueryIndexClient, error) 2003 /// DeleteIndex deletes the batch of index entries from the index tables 2004 DeleteIndex(ctx context.Context, in *DeleteIndexRequest, opts ...grpc.CallOption) (*empty.Empty, error) 2005 /// PutChunks saves the batch of chunks into the chunk tables. 2006 PutChunks(ctx context.Context, in *PutChunksRequest, opts ...grpc.CallOption) (*empty.Empty, error) 2007 /// GetChunks requests for batch of chunks and the batch of chunks are sent back in rpc streams 2008 /// batching needs to be performed at server level as per requirement instead of sending single chunk per stream. 2009 /// In GetChunks rpc request send buf as nil 2010 GetChunks(ctx context.Context, in *GetChunksRequest, opts ...grpc.CallOption) (GrpcStore_GetChunksClient, error) 2011 /// DeleteChunks deletes the chunks based on chunkID. 2012 DeleteChunks(ctx context.Context, in *ChunkID, opts ...grpc.CallOption) (*empty.Empty, error) 2013 /// Lists all the tables that exists in the database. 2014 ListTables(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*ListTablesResponse, error) 2015 /// Creates a table with provided name & attributes. 2016 CreateTable(ctx context.Context, in *CreateTableRequest, opts ...grpc.CallOption) (*empty.Empty, error) 2017 // Deletes a table using table name provided. 2018 DeleteTable(ctx context.Context, in *DeleteTableRequest, opts ...grpc.CallOption) (*empty.Empty, error) 2019 // Describes a table information for the provided table. 2020 DescribeTable(ctx context.Context, in *DescribeTableRequest, opts ...grpc.CallOption) (*DescribeTableResponse, error) 2021 // Update a table with newly provided table information. 2022 UpdateTable(ctx context.Context, in *UpdateTableRequest, opts ...grpc.CallOption) (*empty.Empty, error) 2023} 2024 2025type grpcStoreClient struct { 2026 cc *grpc.ClientConn 2027} 2028 2029func NewGrpcStoreClient(cc *grpc.ClientConn) GrpcStoreClient { 2030 return &grpcStoreClient{cc} 2031} 2032 2033func (c *grpcStoreClient) WriteIndex(ctx context.Context, in *WriteIndexRequest, opts ...grpc.CallOption) (*empty.Empty, error) { 2034 out := new(empty.Empty) 2035 err := c.cc.Invoke(ctx, "/grpc.grpc_store/WriteIndex", in, out, opts...) 2036 if err != nil { 2037 return nil, err 2038 } 2039 return out, nil 2040} 2041 2042func (c *grpcStoreClient) QueryIndex(ctx context.Context, in *QueryIndexRequest, opts ...grpc.CallOption) (GrpcStore_QueryIndexClient, error) { 2043 stream, err := c.cc.NewStream(ctx, &_GrpcStore_serviceDesc.Streams[0], "/grpc.grpc_store/QueryIndex", opts...) 2044 if err != nil { 2045 return nil, err 2046 } 2047 x := &grpcStoreQueryIndexClient{stream} 2048 if err := x.ClientStream.SendMsg(in); err != nil { 2049 return nil, err 2050 } 2051 if err := x.ClientStream.CloseSend(); err != nil { 2052 return nil, err 2053 } 2054 return x, nil 2055} 2056 2057type GrpcStore_QueryIndexClient interface { 2058 Recv() (*QueryIndexResponse, error) 2059 grpc.ClientStream 2060} 2061 2062type grpcStoreQueryIndexClient struct { 2063 grpc.ClientStream 2064} 2065 2066func (x *grpcStoreQueryIndexClient) Recv() (*QueryIndexResponse, error) { 2067 m := new(QueryIndexResponse) 2068 if err := x.ClientStream.RecvMsg(m); err != nil { 2069 return nil, err 2070 } 2071 return m, nil 2072} 2073 2074func (c *grpcStoreClient) DeleteIndex(ctx context.Context, in *DeleteIndexRequest, opts ...grpc.CallOption) (*empty.Empty, error) { 2075 out := new(empty.Empty) 2076 err := c.cc.Invoke(ctx, "/grpc.grpc_store/DeleteIndex", in, out, opts...) 2077 if err != nil { 2078 return nil, err 2079 } 2080 return out, nil 2081} 2082 2083func (c *grpcStoreClient) PutChunks(ctx context.Context, in *PutChunksRequest, opts ...grpc.CallOption) (*empty.Empty, error) { 2084 out := new(empty.Empty) 2085 err := c.cc.Invoke(ctx, "/grpc.grpc_store/PutChunks", in, out, opts...) 2086 if err != nil { 2087 return nil, err 2088 } 2089 return out, nil 2090} 2091 2092func (c *grpcStoreClient) GetChunks(ctx context.Context, in *GetChunksRequest, opts ...grpc.CallOption) (GrpcStore_GetChunksClient, error) { 2093 stream, err := c.cc.NewStream(ctx, &_GrpcStore_serviceDesc.Streams[1], "/grpc.grpc_store/GetChunks", opts...) 2094 if err != nil { 2095 return nil, err 2096 } 2097 x := &grpcStoreGetChunksClient{stream} 2098 if err := x.ClientStream.SendMsg(in); err != nil { 2099 return nil, err 2100 } 2101 if err := x.ClientStream.CloseSend(); err != nil { 2102 return nil, err 2103 } 2104 return x, nil 2105} 2106 2107type GrpcStore_GetChunksClient interface { 2108 Recv() (*GetChunksResponse, error) 2109 grpc.ClientStream 2110} 2111 2112type grpcStoreGetChunksClient struct { 2113 grpc.ClientStream 2114} 2115 2116func (x *grpcStoreGetChunksClient) Recv() (*GetChunksResponse, error) { 2117 m := new(GetChunksResponse) 2118 if err := x.ClientStream.RecvMsg(m); err != nil { 2119 return nil, err 2120 } 2121 return m, nil 2122} 2123 2124func (c *grpcStoreClient) DeleteChunks(ctx context.Context, in *ChunkID, opts ...grpc.CallOption) (*empty.Empty, error) { 2125 out := new(empty.Empty) 2126 err := c.cc.Invoke(ctx, "/grpc.grpc_store/DeleteChunks", in, out, opts...) 2127 if err != nil { 2128 return nil, err 2129 } 2130 return out, nil 2131} 2132 2133func (c *grpcStoreClient) ListTables(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*ListTablesResponse, error) { 2134 out := new(ListTablesResponse) 2135 err := c.cc.Invoke(ctx, "/grpc.grpc_store/ListTables", in, out, opts...) 2136 if err != nil { 2137 return nil, err 2138 } 2139 return out, nil 2140} 2141 2142func (c *grpcStoreClient) CreateTable(ctx context.Context, in *CreateTableRequest, opts ...grpc.CallOption) (*empty.Empty, error) { 2143 out := new(empty.Empty) 2144 err := c.cc.Invoke(ctx, "/grpc.grpc_store/CreateTable", in, out, opts...) 2145 if err != nil { 2146 return nil, err 2147 } 2148 return out, nil 2149} 2150 2151func (c *grpcStoreClient) DeleteTable(ctx context.Context, in *DeleteTableRequest, opts ...grpc.CallOption) (*empty.Empty, error) { 2152 out := new(empty.Empty) 2153 err := c.cc.Invoke(ctx, "/grpc.grpc_store/DeleteTable", in, out, opts...) 2154 if err != nil { 2155 return nil, err 2156 } 2157 return out, nil 2158} 2159 2160func (c *grpcStoreClient) DescribeTable(ctx context.Context, in *DescribeTableRequest, opts ...grpc.CallOption) (*DescribeTableResponse, error) { 2161 out := new(DescribeTableResponse) 2162 err := c.cc.Invoke(ctx, "/grpc.grpc_store/DescribeTable", in, out, opts...) 2163 if err != nil { 2164 return nil, err 2165 } 2166 return out, nil 2167} 2168 2169func (c *grpcStoreClient) UpdateTable(ctx context.Context, in *UpdateTableRequest, opts ...grpc.CallOption) (*empty.Empty, error) { 2170 out := new(empty.Empty) 2171 err := c.cc.Invoke(ctx, "/grpc.grpc_store/UpdateTable", in, out, opts...) 2172 if err != nil { 2173 return nil, err 2174 } 2175 return out, nil 2176} 2177 2178// GrpcStoreServer is the server API for GrpcStore service. 2179type GrpcStoreServer interface { 2180 /// WriteIndex writes batch of indexes to the index tables. 2181 WriteIndex(context.Context, *WriteIndexRequest) (*empty.Empty, error) 2182 /// QueryIndex reads the indexes required for given query & sends back the batch of rows 2183 /// in rpc streams 2184 QueryIndex(*QueryIndexRequest, GrpcStore_QueryIndexServer) error 2185 /// DeleteIndex deletes the batch of index entries from the index tables 2186 DeleteIndex(context.Context, *DeleteIndexRequest) (*empty.Empty, error) 2187 /// PutChunks saves the batch of chunks into the chunk tables. 2188 PutChunks(context.Context, *PutChunksRequest) (*empty.Empty, error) 2189 /// GetChunks requests for batch of chunks and the batch of chunks are sent back in rpc streams 2190 /// batching needs to be performed at server level as per requirement instead of sending single chunk per stream. 2191 /// In GetChunks rpc request send buf as nil 2192 GetChunks(*GetChunksRequest, GrpcStore_GetChunksServer) error 2193 /// DeleteChunks deletes the chunks based on chunkID. 2194 DeleteChunks(context.Context, *ChunkID) (*empty.Empty, error) 2195 /// Lists all the tables that exists in the database. 2196 ListTables(context.Context, *empty.Empty) (*ListTablesResponse, error) 2197 /// Creates a table with provided name & attributes. 2198 CreateTable(context.Context, *CreateTableRequest) (*empty.Empty, error) 2199 // Deletes a table using table name provided. 2200 DeleteTable(context.Context, *DeleteTableRequest) (*empty.Empty, error) 2201 // Describes a table information for the provided table. 2202 DescribeTable(context.Context, *DescribeTableRequest) (*DescribeTableResponse, error) 2203 // Update a table with newly provided table information. 2204 UpdateTable(context.Context, *UpdateTableRequest) (*empty.Empty, error) 2205} 2206 2207// UnimplementedGrpcStoreServer can be embedded to have forward compatible implementations. 2208type UnimplementedGrpcStoreServer struct { 2209} 2210 2211func (*UnimplementedGrpcStoreServer) WriteIndex(ctx context.Context, req *WriteIndexRequest) (*empty.Empty, error) { 2212 return nil, status.Errorf(codes.Unimplemented, "method WriteIndex not implemented") 2213} 2214func (*UnimplementedGrpcStoreServer) QueryIndex(req *QueryIndexRequest, srv GrpcStore_QueryIndexServer) error { 2215 return status.Errorf(codes.Unimplemented, "method QueryIndex not implemented") 2216} 2217func (*UnimplementedGrpcStoreServer) DeleteIndex(ctx context.Context, req *DeleteIndexRequest) (*empty.Empty, error) { 2218 return nil, status.Errorf(codes.Unimplemented, "method DeleteIndex not implemented") 2219} 2220func (*UnimplementedGrpcStoreServer) PutChunks(ctx context.Context, req *PutChunksRequest) (*empty.Empty, error) { 2221 return nil, status.Errorf(codes.Unimplemented, "method PutChunks not implemented") 2222} 2223func (*UnimplementedGrpcStoreServer) GetChunks(req *GetChunksRequest, srv GrpcStore_GetChunksServer) error { 2224 return status.Errorf(codes.Unimplemented, "method GetChunks not implemented") 2225} 2226func (*UnimplementedGrpcStoreServer) DeleteChunks(ctx context.Context, req *ChunkID) (*empty.Empty, error) { 2227 return nil, status.Errorf(codes.Unimplemented, "method DeleteChunks not implemented") 2228} 2229func (*UnimplementedGrpcStoreServer) ListTables(ctx context.Context, req *empty.Empty) (*ListTablesResponse, error) { 2230 return nil, status.Errorf(codes.Unimplemented, "method ListTables not implemented") 2231} 2232func (*UnimplementedGrpcStoreServer) CreateTable(ctx context.Context, req *CreateTableRequest) (*empty.Empty, error) { 2233 return nil, status.Errorf(codes.Unimplemented, "method CreateTable not implemented") 2234} 2235func (*UnimplementedGrpcStoreServer) DeleteTable(ctx context.Context, req *DeleteTableRequest) (*empty.Empty, error) { 2236 return nil, status.Errorf(codes.Unimplemented, "method DeleteTable not implemented") 2237} 2238func (*UnimplementedGrpcStoreServer) DescribeTable(ctx context.Context, req *DescribeTableRequest) (*DescribeTableResponse, error) { 2239 return nil, status.Errorf(codes.Unimplemented, "method DescribeTable not implemented") 2240} 2241func (*UnimplementedGrpcStoreServer) UpdateTable(ctx context.Context, req *UpdateTableRequest) (*empty.Empty, error) { 2242 return nil, status.Errorf(codes.Unimplemented, "method UpdateTable not implemented") 2243} 2244 2245func RegisterGrpcStoreServer(s *grpc.Server, srv GrpcStoreServer) { 2246 s.RegisterService(&_GrpcStore_serviceDesc, srv) 2247} 2248 2249func _GrpcStore_WriteIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 2250 in := new(WriteIndexRequest) 2251 if err := dec(in); err != nil { 2252 return nil, err 2253 } 2254 if interceptor == nil { 2255 return srv.(GrpcStoreServer).WriteIndex(ctx, in) 2256 } 2257 info := &grpc.UnaryServerInfo{ 2258 Server: srv, 2259 FullMethod: "/grpc.grpc_store/WriteIndex", 2260 } 2261 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 2262 return srv.(GrpcStoreServer).WriteIndex(ctx, req.(*WriteIndexRequest)) 2263 } 2264 return interceptor(ctx, in, info, handler) 2265} 2266 2267func _GrpcStore_QueryIndex_Handler(srv interface{}, stream grpc.ServerStream) error { 2268 m := new(QueryIndexRequest) 2269 if err := stream.RecvMsg(m); err != nil { 2270 return err 2271 } 2272 return srv.(GrpcStoreServer).QueryIndex(m, &grpcStoreQueryIndexServer{stream}) 2273} 2274 2275type GrpcStore_QueryIndexServer interface { 2276 Send(*QueryIndexResponse) error 2277 grpc.ServerStream 2278} 2279 2280type grpcStoreQueryIndexServer struct { 2281 grpc.ServerStream 2282} 2283 2284func (x *grpcStoreQueryIndexServer) Send(m *QueryIndexResponse) error { 2285 return x.ServerStream.SendMsg(m) 2286} 2287 2288func _GrpcStore_DeleteIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 2289 in := new(DeleteIndexRequest) 2290 if err := dec(in); err != nil { 2291 return nil, err 2292 } 2293 if interceptor == nil { 2294 return srv.(GrpcStoreServer).DeleteIndex(ctx, in) 2295 } 2296 info := &grpc.UnaryServerInfo{ 2297 Server: srv, 2298 FullMethod: "/grpc.grpc_store/DeleteIndex", 2299 } 2300 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 2301 return srv.(GrpcStoreServer).DeleteIndex(ctx, req.(*DeleteIndexRequest)) 2302 } 2303 return interceptor(ctx, in, info, handler) 2304} 2305 2306func _GrpcStore_PutChunks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 2307 in := new(PutChunksRequest) 2308 if err := dec(in); err != nil { 2309 return nil, err 2310 } 2311 if interceptor == nil { 2312 return srv.(GrpcStoreServer).PutChunks(ctx, in) 2313 } 2314 info := &grpc.UnaryServerInfo{ 2315 Server: srv, 2316 FullMethod: "/grpc.grpc_store/PutChunks", 2317 } 2318 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 2319 return srv.(GrpcStoreServer).PutChunks(ctx, req.(*PutChunksRequest)) 2320 } 2321 return interceptor(ctx, in, info, handler) 2322} 2323 2324func _GrpcStore_GetChunks_Handler(srv interface{}, stream grpc.ServerStream) error { 2325 m := new(GetChunksRequest) 2326 if err := stream.RecvMsg(m); err != nil { 2327 return err 2328 } 2329 return srv.(GrpcStoreServer).GetChunks(m, &grpcStoreGetChunksServer{stream}) 2330} 2331 2332type GrpcStore_GetChunksServer interface { 2333 Send(*GetChunksResponse) error 2334 grpc.ServerStream 2335} 2336 2337type grpcStoreGetChunksServer struct { 2338 grpc.ServerStream 2339} 2340 2341func (x *grpcStoreGetChunksServer) Send(m *GetChunksResponse) error { 2342 return x.ServerStream.SendMsg(m) 2343} 2344 2345func _GrpcStore_DeleteChunks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 2346 in := new(ChunkID) 2347 if err := dec(in); err != nil { 2348 return nil, err 2349 } 2350 if interceptor == nil { 2351 return srv.(GrpcStoreServer).DeleteChunks(ctx, in) 2352 } 2353 info := &grpc.UnaryServerInfo{ 2354 Server: srv, 2355 FullMethod: "/grpc.grpc_store/DeleteChunks", 2356 } 2357 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 2358 return srv.(GrpcStoreServer).DeleteChunks(ctx, req.(*ChunkID)) 2359 } 2360 return interceptor(ctx, in, info, handler) 2361} 2362 2363func _GrpcStore_ListTables_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 2364 in := new(empty.Empty) 2365 if err := dec(in); err != nil { 2366 return nil, err 2367 } 2368 if interceptor == nil { 2369 return srv.(GrpcStoreServer).ListTables(ctx, in) 2370 } 2371 info := &grpc.UnaryServerInfo{ 2372 Server: srv, 2373 FullMethod: "/grpc.grpc_store/ListTables", 2374 } 2375 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 2376 return srv.(GrpcStoreServer).ListTables(ctx, req.(*empty.Empty)) 2377 } 2378 return interceptor(ctx, in, info, handler) 2379} 2380 2381func _GrpcStore_CreateTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 2382 in := new(CreateTableRequest) 2383 if err := dec(in); err != nil { 2384 return nil, err 2385 } 2386 if interceptor == nil { 2387 return srv.(GrpcStoreServer).CreateTable(ctx, in) 2388 } 2389 info := &grpc.UnaryServerInfo{ 2390 Server: srv, 2391 FullMethod: "/grpc.grpc_store/CreateTable", 2392 } 2393 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 2394 return srv.(GrpcStoreServer).CreateTable(ctx, req.(*CreateTableRequest)) 2395 } 2396 return interceptor(ctx, in, info, handler) 2397} 2398 2399func _GrpcStore_DeleteTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 2400 in := new(DeleteTableRequest) 2401 if err := dec(in); err != nil { 2402 return nil, err 2403 } 2404 if interceptor == nil { 2405 return srv.(GrpcStoreServer).DeleteTable(ctx, in) 2406 } 2407 info := &grpc.UnaryServerInfo{ 2408 Server: srv, 2409 FullMethod: "/grpc.grpc_store/DeleteTable", 2410 } 2411 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 2412 return srv.(GrpcStoreServer).DeleteTable(ctx, req.(*DeleteTableRequest)) 2413 } 2414 return interceptor(ctx, in, info, handler) 2415} 2416 2417func _GrpcStore_DescribeTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 2418 in := new(DescribeTableRequest) 2419 if err := dec(in); err != nil { 2420 return nil, err 2421 } 2422 if interceptor == nil { 2423 return srv.(GrpcStoreServer).DescribeTable(ctx, in) 2424 } 2425 info := &grpc.UnaryServerInfo{ 2426 Server: srv, 2427 FullMethod: "/grpc.grpc_store/DescribeTable", 2428 } 2429 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 2430 return srv.(GrpcStoreServer).DescribeTable(ctx, req.(*DescribeTableRequest)) 2431 } 2432 return interceptor(ctx, in, info, handler) 2433} 2434 2435func _GrpcStore_UpdateTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 2436 in := new(UpdateTableRequest) 2437 if err := dec(in); err != nil { 2438 return nil, err 2439 } 2440 if interceptor == nil { 2441 return srv.(GrpcStoreServer).UpdateTable(ctx, in) 2442 } 2443 info := &grpc.UnaryServerInfo{ 2444 Server: srv, 2445 FullMethod: "/grpc.grpc_store/UpdateTable", 2446 } 2447 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 2448 return srv.(GrpcStoreServer).UpdateTable(ctx, req.(*UpdateTableRequest)) 2449 } 2450 return interceptor(ctx, in, info, handler) 2451} 2452 2453var _GrpcStore_serviceDesc = grpc.ServiceDesc{ 2454 ServiceName: "grpc.grpc_store", 2455 HandlerType: (*GrpcStoreServer)(nil), 2456 Methods: []grpc.MethodDesc{ 2457 { 2458 MethodName: "WriteIndex", 2459 Handler: _GrpcStore_WriteIndex_Handler, 2460 }, 2461 { 2462 MethodName: "DeleteIndex", 2463 Handler: _GrpcStore_DeleteIndex_Handler, 2464 }, 2465 { 2466 MethodName: "PutChunks", 2467 Handler: _GrpcStore_PutChunks_Handler, 2468 }, 2469 { 2470 MethodName: "DeleteChunks", 2471 Handler: _GrpcStore_DeleteChunks_Handler, 2472 }, 2473 { 2474 MethodName: "ListTables", 2475 Handler: _GrpcStore_ListTables_Handler, 2476 }, 2477 { 2478 MethodName: "CreateTable", 2479 Handler: _GrpcStore_CreateTable_Handler, 2480 }, 2481 { 2482 MethodName: "DeleteTable", 2483 Handler: _GrpcStore_DeleteTable_Handler, 2484 }, 2485 { 2486 MethodName: "DescribeTable", 2487 Handler: _GrpcStore_DescribeTable_Handler, 2488 }, 2489 { 2490 MethodName: "UpdateTable", 2491 Handler: _GrpcStore_UpdateTable_Handler, 2492 }, 2493 }, 2494 Streams: []grpc.StreamDesc{ 2495 { 2496 StreamName: "QueryIndex", 2497 Handler: _GrpcStore_QueryIndex_Handler, 2498 ServerStreams: true, 2499 }, 2500 { 2501 StreamName: "GetChunks", 2502 Handler: _GrpcStore_GetChunks_Handler, 2503 ServerStreams: true, 2504 }, 2505 }, 2506 Metadata: "pkg/storage/chunk/grpc/grpc.proto", 2507} 2508 2509func (m *PutChunksRequest) Marshal() (dAtA []byte, err error) { 2510 size := m.Size() 2511 dAtA = make([]byte, size) 2512 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2513 if err != nil { 2514 return nil, err 2515 } 2516 return dAtA[:n], nil 2517} 2518 2519func (m *PutChunksRequest) MarshalTo(dAtA []byte) (int, error) { 2520 size := m.Size() 2521 return m.MarshalToSizedBuffer(dAtA[:size]) 2522} 2523 2524func (m *PutChunksRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2525 i := len(dAtA) 2526 _ = i 2527 var l int 2528 _ = l 2529 if len(m.Chunks) > 0 { 2530 for iNdEx := len(m.Chunks) - 1; iNdEx >= 0; iNdEx-- { 2531 { 2532 size, err := m.Chunks[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 2533 if err != nil { 2534 return 0, err 2535 } 2536 i -= size 2537 i = encodeVarintGrpc(dAtA, i, uint64(size)) 2538 } 2539 i-- 2540 dAtA[i] = 0xa 2541 } 2542 } 2543 return len(dAtA) - i, nil 2544} 2545 2546func (m *GetChunksRequest) Marshal() (dAtA []byte, err error) { 2547 size := m.Size() 2548 dAtA = make([]byte, size) 2549 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2550 if err != nil { 2551 return nil, err 2552 } 2553 return dAtA[:n], nil 2554} 2555 2556func (m *GetChunksRequest) MarshalTo(dAtA []byte) (int, error) { 2557 size := m.Size() 2558 return m.MarshalToSizedBuffer(dAtA[:size]) 2559} 2560 2561func (m *GetChunksRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2562 i := len(dAtA) 2563 _ = i 2564 var l int 2565 _ = l 2566 if len(m.Chunks) > 0 { 2567 for iNdEx := len(m.Chunks) - 1; iNdEx >= 0; iNdEx-- { 2568 { 2569 size, err := m.Chunks[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 2570 if err != nil { 2571 return 0, err 2572 } 2573 i -= size 2574 i = encodeVarintGrpc(dAtA, i, uint64(size)) 2575 } 2576 i-- 2577 dAtA[i] = 0xa 2578 } 2579 } 2580 return len(dAtA) - i, nil 2581} 2582 2583func (m *GetChunksResponse) Marshal() (dAtA []byte, err error) { 2584 size := m.Size() 2585 dAtA = make([]byte, size) 2586 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2587 if err != nil { 2588 return nil, err 2589 } 2590 return dAtA[:n], nil 2591} 2592 2593func (m *GetChunksResponse) MarshalTo(dAtA []byte) (int, error) { 2594 size := m.Size() 2595 return m.MarshalToSizedBuffer(dAtA[:size]) 2596} 2597 2598func (m *GetChunksResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2599 i := len(dAtA) 2600 _ = i 2601 var l int 2602 _ = l 2603 if len(m.Chunks) > 0 { 2604 for iNdEx := len(m.Chunks) - 1; iNdEx >= 0; iNdEx-- { 2605 { 2606 size, err := m.Chunks[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 2607 if err != nil { 2608 return 0, err 2609 } 2610 i -= size 2611 i = encodeVarintGrpc(dAtA, i, uint64(size)) 2612 } 2613 i-- 2614 dAtA[i] = 0xa 2615 } 2616 } 2617 return len(dAtA) - i, nil 2618} 2619 2620func (m *Chunk) Marshal() (dAtA []byte, err error) { 2621 size := m.Size() 2622 dAtA = make([]byte, size) 2623 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2624 if err != nil { 2625 return nil, err 2626 } 2627 return dAtA[:n], nil 2628} 2629 2630func (m *Chunk) MarshalTo(dAtA []byte) (int, error) { 2631 size := m.Size() 2632 return m.MarshalToSizedBuffer(dAtA[:size]) 2633} 2634 2635func (m *Chunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2636 i := len(dAtA) 2637 _ = i 2638 var l int 2639 _ = l 2640 if len(m.TableName) > 0 { 2641 i -= len(m.TableName) 2642 copy(dAtA[i:], m.TableName) 2643 i = encodeVarintGrpc(dAtA, i, uint64(len(m.TableName))) 2644 i-- 2645 dAtA[i] = 0x1a 2646 } 2647 if len(m.Key) > 0 { 2648 i -= len(m.Key) 2649 copy(dAtA[i:], m.Key) 2650 i = encodeVarintGrpc(dAtA, i, uint64(len(m.Key))) 2651 i-- 2652 dAtA[i] = 0x12 2653 } 2654 if len(m.Encoded) > 0 { 2655 i -= len(m.Encoded) 2656 copy(dAtA[i:], m.Encoded) 2657 i = encodeVarintGrpc(dAtA, i, uint64(len(m.Encoded))) 2658 i-- 2659 dAtA[i] = 0xa 2660 } 2661 return len(dAtA) - i, nil 2662} 2663 2664func (m *ChunkID) Marshal() (dAtA []byte, err error) { 2665 size := m.Size() 2666 dAtA = make([]byte, size) 2667 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2668 if err != nil { 2669 return nil, err 2670 } 2671 return dAtA[:n], nil 2672} 2673 2674func (m *ChunkID) MarshalTo(dAtA []byte) (int, error) { 2675 size := m.Size() 2676 return m.MarshalToSizedBuffer(dAtA[:size]) 2677} 2678 2679func (m *ChunkID) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2680 i := len(dAtA) 2681 _ = i 2682 var l int 2683 _ = l 2684 if len(m.ChunkID) > 0 { 2685 i -= len(m.ChunkID) 2686 copy(dAtA[i:], m.ChunkID) 2687 i = encodeVarintGrpc(dAtA, i, uint64(len(m.ChunkID))) 2688 i-- 2689 dAtA[i] = 0xa 2690 } 2691 return len(dAtA) - i, nil 2692} 2693 2694func (m *DeleteTableRequest) Marshal() (dAtA []byte, err error) { 2695 size := m.Size() 2696 dAtA = make([]byte, size) 2697 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2698 if err != nil { 2699 return nil, err 2700 } 2701 return dAtA[:n], nil 2702} 2703 2704func (m *DeleteTableRequest) MarshalTo(dAtA []byte) (int, error) { 2705 size := m.Size() 2706 return m.MarshalToSizedBuffer(dAtA[:size]) 2707} 2708 2709func (m *DeleteTableRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2710 i := len(dAtA) 2711 _ = i 2712 var l int 2713 _ = l 2714 if len(m.TableName) > 0 { 2715 i -= len(m.TableName) 2716 copy(dAtA[i:], m.TableName) 2717 i = encodeVarintGrpc(dAtA, i, uint64(len(m.TableName))) 2718 i-- 2719 dAtA[i] = 0xa 2720 } 2721 return len(dAtA) - i, nil 2722} 2723 2724func (m *DescribeTableRequest) Marshal() (dAtA []byte, err error) { 2725 size := m.Size() 2726 dAtA = make([]byte, size) 2727 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2728 if err != nil { 2729 return nil, err 2730 } 2731 return dAtA[:n], nil 2732} 2733 2734func (m *DescribeTableRequest) MarshalTo(dAtA []byte) (int, error) { 2735 size := m.Size() 2736 return m.MarshalToSizedBuffer(dAtA[:size]) 2737} 2738 2739func (m *DescribeTableRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2740 i := len(dAtA) 2741 _ = i 2742 var l int 2743 _ = l 2744 if len(m.TableName) > 0 { 2745 i -= len(m.TableName) 2746 copy(dAtA[i:], m.TableName) 2747 i = encodeVarintGrpc(dAtA, i, uint64(len(m.TableName))) 2748 i-- 2749 dAtA[i] = 0xa 2750 } 2751 return len(dAtA) - i, nil 2752} 2753 2754func (m *WriteBatch) Marshal() (dAtA []byte, err error) { 2755 size := m.Size() 2756 dAtA = make([]byte, size) 2757 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2758 if err != nil { 2759 return nil, err 2760 } 2761 return dAtA[:n], nil 2762} 2763 2764func (m *WriteBatch) MarshalTo(dAtA []byte) (int, error) { 2765 size := m.Size() 2766 return m.MarshalToSizedBuffer(dAtA[:size]) 2767} 2768 2769func (m *WriteBatch) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2770 i := len(dAtA) 2771 _ = i 2772 var l int 2773 _ = l 2774 if len(m.Deletes) > 0 { 2775 for iNdEx := len(m.Deletes) - 1; iNdEx >= 0; iNdEx-- { 2776 { 2777 size, err := m.Deletes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 2778 if err != nil { 2779 return 0, err 2780 } 2781 i -= size 2782 i = encodeVarintGrpc(dAtA, i, uint64(size)) 2783 } 2784 i-- 2785 dAtA[i] = 0x12 2786 } 2787 } 2788 if len(m.Writes) > 0 { 2789 for iNdEx := len(m.Writes) - 1; iNdEx >= 0; iNdEx-- { 2790 { 2791 size, err := m.Writes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 2792 if err != nil { 2793 return 0, err 2794 } 2795 i -= size 2796 i = encodeVarintGrpc(dAtA, i, uint64(size)) 2797 } 2798 i-- 2799 dAtA[i] = 0xa 2800 } 2801 } 2802 return len(dAtA) - i, nil 2803} 2804 2805func (m *WriteIndexRequest) Marshal() (dAtA []byte, err error) { 2806 size := m.Size() 2807 dAtA = make([]byte, size) 2808 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2809 if err != nil { 2810 return nil, err 2811 } 2812 return dAtA[:n], nil 2813} 2814 2815func (m *WriteIndexRequest) MarshalTo(dAtA []byte) (int, error) { 2816 size := m.Size() 2817 return m.MarshalToSizedBuffer(dAtA[:size]) 2818} 2819 2820func (m *WriteIndexRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2821 i := len(dAtA) 2822 _ = i 2823 var l int 2824 _ = l 2825 if len(m.Writes) > 0 { 2826 for iNdEx := len(m.Writes) - 1; iNdEx >= 0; iNdEx-- { 2827 { 2828 size, err := m.Writes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 2829 if err != nil { 2830 return 0, err 2831 } 2832 i -= size 2833 i = encodeVarintGrpc(dAtA, i, uint64(size)) 2834 } 2835 i-- 2836 dAtA[i] = 0xa 2837 } 2838 } 2839 return len(dAtA) - i, nil 2840} 2841 2842func (m *DeleteIndexRequest) Marshal() (dAtA []byte, err error) { 2843 size := m.Size() 2844 dAtA = make([]byte, size) 2845 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2846 if err != nil { 2847 return nil, err 2848 } 2849 return dAtA[:n], nil 2850} 2851 2852func (m *DeleteIndexRequest) MarshalTo(dAtA []byte) (int, error) { 2853 size := m.Size() 2854 return m.MarshalToSizedBuffer(dAtA[:size]) 2855} 2856 2857func (m *DeleteIndexRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2858 i := len(dAtA) 2859 _ = i 2860 var l int 2861 _ = l 2862 if len(m.Deletes) > 0 { 2863 for iNdEx := len(m.Deletes) - 1; iNdEx >= 0; iNdEx-- { 2864 { 2865 size, err := m.Deletes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 2866 if err != nil { 2867 return 0, err 2868 } 2869 i -= size 2870 i = encodeVarintGrpc(dAtA, i, uint64(size)) 2871 } 2872 i-- 2873 dAtA[i] = 0xa 2874 } 2875 } 2876 return len(dAtA) - i, nil 2877} 2878 2879func (m *QueryIndexResponse) Marshal() (dAtA []byte, err error) { 2880 size := m.Size() 2881 dAtA = make([]byte, size) 2882 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2883 if err != nil { 2884 return nil, err 2885 } 2886 return dAtA[:n], nil 2887} 2888 2889func (m *QueryIndexResponse) MarshalTo(dAtA []byte) (int, error) { 2890 size := m.Size() 2891 return m.MarshalToSizedBuffer(dAtA[:size]) 2892} 2893 2894func (m *QueryIndexResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2895 i := len(dAtA) 2896 _ = i 2897 var l int 2898 _ = l 2899 if len(m.Rows) > 0 { 2900 for iNdEx := len(m.Rows) - 1; iNdEx >= 0; iNdEx-- { 2901 { 2902 size, err := m.Rows[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 2903 if err != nil { 2904 return 0, err 2905 } 2906 i -= size 2907 i = encodeVarintGrpc(dAtA, i, uint64(size)) 2908 } 2909 i-- 2910 dAtA[i] = 0xa 2911 } 2912 } 2913 return len(dAtA) - i, nil 2914} 2915 2916func (m *Row) Marshal() (dAtA []byte, err error) { 2917 size := m.Size() 2918 dAtA = make([]byte, size) 2919 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2920 if err != nil { 2921 return nil, err 2922 } 2923 return dAtA[:n], nil 2924} 2925 2926func (m *Row) MarshalTo(dAtA []byte) (int, error) { 2927 size := m.Size() 2928 return m.MarshalToSizedBuffer(dAtA[:size]) 2929} 2930 2931func (m *Row) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2932 i := len(dAtA) 2933 _ = i 2934 var l int 2935 _ = l 2936 if len(m.Value) > 0 { 2937 i -= len(m.Value) 2938 copy(dAtA[i:], m.Value) 2939 i = encodeVarintGrpc(dAtA, i, uint64(len(m.Value))) 2940 i-- 2941 dAtA[i] = 0x12 2942 } 2943 if len(m.RangeValue) > 0 { 2944 i -= len(m.RangeValue) 2945 copy(dAtA[i:], m.RangeValue) 2946 i = encodeVarintGrpc(dAtA, i, uint64(len(m.RangeValue))) 2947 i-- 2948 dAtA[i] = 0xa 2949 } 2950 return len(dAtA) - i, nil 2951} 2952 2953func (m *IndexEntry) Marshal() (dAtA []byte, err error) { 2954 size := m.Size() 2955 dAtA = make([]byte, size) 2956 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 2957 if err != nil { 2958 return nil, err 2959 } 2960 return dAtA[:n], nil 2961} 2962 2963func (m *IndexEntry) MarshalTo(dAtA []byte) (int, error) { 2964 size := m.Size() 2965 return m.MarshalToSizedBuffer(dAtA[:size]) 2966} 2967 2968func (m *IndexEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) { 2969 i := len(dAtA) 2970 _ = i 2971 var l int 2972 _ = l 2973 if len(m.Value) > 0 { 2974 i -= len(m.Value) 2975 copy(dAtA[i:], m.Value) 2976 i = encodeVarintGrpc(dAtA, i, uint64(len(m.Value))) 2977 i-- 2978 dAtA[i] = 0x22 2979 } 2980 if len(m.RangeValue) > 0 { 2981 i -= len(m.RangeValue) 2982 copy(dAtA[i:], m.RangeValue) 2983 i = encodeVarintGrpc(dAtA, i, uint64(len(m.RangeValue))) 2984 i-- 2985 dAtA[i] = 0x1a 2986 } 2987 if len(m.HashValue) > 0 { 2988 i -= len(m.HashValue) 2989 copy(dAtA[i:], m.HashValue) 2990 i = encodeVarintGrpc(dAtA, i, uint64(len(m.HashValue))) 2991 i-- 2992 dAtA[i] = 0x12 2993 } 2994 if len(m.TableName) > 0 { 2995 i -= len(m.TableName) 2996 copy(dAtA[i:], m.TableName) 2997 i = encodeVarintGrpc(dAtA, i, uint64(len(m.TableName))) 2998 i-- 2999 dAtA[i] = 0xa 3000 } 3001 return len(dAtA) - i, nil 3002} 3003 3004func (m *QueryIndexRequest) Marshal() (dAtA []byte, err error) { 3005 size := m.Size() 3006 dAtA = make([]byte, size) 3007 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 3008 if err != nil { 3009 return nil, err 3010 } 3011 return dAtA[:n], nil 3012} 3013 3014func (m *QueryIndexRequest) MarshalTo(dAtA []byte) (int, error) { 3015 size := m.Size() 3016 return m.MarshalToSizedBuffer(dAtA[:size]) 3017} 3018 3019func (m *QueryIndexRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { 3020 i := len(dAtA) 3021 _ = i 3022 var l int 3023 _ = l 3024 if m.Immutable { 3025 i-- 3026 if m.Immutable { 3027 dAtA[i] = 1 3028 } else { 3029 dAtA[i] = 0 3030 } 3031 i-- 3032 dAtA[i] = 0x30 3033 } 3034 if len(m.ValueEqual) > 0 { 3035 i -= len(m.ValueEqual) 3036 copy(dAtA[i:], m.ValueEqual) 3037 i = encodeVarintGrpc(dAtA, i, uint64(len(m.ValueEqual))) 3038 i-- 3039 dAtA[i] = 0x2a 3040 } 3041 if len(m.RangeValueStart) > 0 { 3042 i -= len(m.RangeValueStart) 3043 copy(dAtA[i:], m.RangeValueStart) 3044 i = encodeVarintGrpc(dAtA, i, uint64(len(m.RangeValueStart))) 3045 i-- 3046 dAtA[i] = 0x22 3047 } 3048 if len(m.RangeValuePrefix) > 0 { 3049 i -= len(m.RangeValuePrefix) 3050 copy(dAtA[i:], m.RangeValuePrefix) 3051 i = encodeVarintGrpc(dAtA, i, uint64(len(m.RangeValuePrefix))) 3052 i-- 3053 dAtA[i] = 0x1a 3054 } 3055 if len(m.HashValue) > 0 { 3056 i -= len(m.HashValue) 3057 copy(dAtA[i:], m.HashValue) 3058 i = encodeVarintGrpc(dAtA, i, uint64(len(m.HashValue))) 3059 i-- 3060 dAtA[i] = 0x12 3061 } 3062 if len(m.TableName) > 0 { 3063 i -= len(m.TableName) 3064 copy(dAtA[i:], m.TableName) 3065 i = encodeVarintGrpc(dAtA, i, uint64(len(m.TableName))) 3066 i-- 3067 dAtA[i] = 0xa 3068 } 3069 return len(dAtA) - i, nil 3070} 3071 3072func (m *UpdateTableRequest) Marshal() (dAtA []byte, err error) { 3073 size := m.Size() 3074 dAtA = make([]byte, size) 3075 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 3076 if err != nil { 3077 return nil, err 3078 } 3079 return dAtA[:n], nil 3080} 3081 3082func (m *UpdateTableRequest) MarshalTo(dAtA []byte) (int, error) { 3083 size := m.Size() 3084 return m.MarshalToSizedBuffer(dAtA[:size]) 3085} 3086 3087func (m *UpdateTableRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { 3088 i := len(dAtA) 3089 _ = i 3090 var l int 3091 _ = l 3092 if m.Expected != nil { 3093 { 3094 size, err := m.Expected.MarshalToSizedBuffer(dAtA[:i]) 3095 if err != nil { 3096 return 0, err 3097 } 3098 i -= size 3099 i = encodeVarintGrpc(dAtA, i, uint64(size)) 3100 } 3101 i-- 3102 dAtA[i] = 0x12 3103 } 3104 if m.Current != nil { 3105 { 3106 size, err := m.Current.MarshalToSizedBuffer(dAtA[:i]) 3107 if err != nil { 3108 return 0, err 3109 } 3110 i -= size 3111 i = encodeVarintGrpc(dAtA, i, uint64(size)) 3112 } 3113 i-- 3114 dAtA[i] = 0xa 3115 } 3116 return len(dAtA) - i, nil 3117} 3118 3119func (m *DescribeTableResponse) Marshal() (dAtA []byte, err error) { 3120 size := m.Size() 3121 dAtA = make([]byte, size) 3122 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 3123 if err != nil { 3124 return nil, err 3125 } 3126 return dAtA[:n], nil 3127} 3128 3129func (m *DescribeTableResponse) MarshalTo(dAtA []byte) (int, error) { 3130 size := m.Size() 3131 return m.MarshalToSizedBuffer(dAtA[:size]) 3132} 3133 3134func (m *DescribeTableResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { 3135 i := len(dAtA) 3136 _ = i 3137 var l int 3138 _ = l 3139 if m.IsActive { 3140 i-- 3141 if m.IsActive { 3142 dAtA[i] = 1 3143 } else { 3144 dAtA[i] = 0 3145 } 3146 i-- 3147 dAtA[i] = 0x10 3148 } 3149 if m.Desc != nil { 3150 { 3151 size, err := m.Desc.MarshalToSizedBuffer(dAtA[:i]) 3152 if err != nil { 3153 return 0, err 3154 } 3155 i -= size 3156 i = encodeVarintGrpc(dAtA, i, uint64(size)) 3157 } 3158 i-- 3159 dAtA[i] = 0xa 3160 } 3161 return len(dAtA) - i, nil 3162} 3163 3164func (m *CreateTableRequest) Marshal() (dAtA []byte, err error) { 3165 size := m.Size() 3166 dAtA = make([]byte, size) 3167 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 3168 if err != nil { 3169 return nil, err 3170 } 3171 return dAtA[:n], nil 3172} 3173 3174func (m *CreateTableRequest) MarshalTo(dAtA []byte) (int, error) { 3175 size := m.Size() 3176 return m.MarshalToSizedBuffer(dAtA[:size]) 3177} 3178 3179func (m *CreateTableRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { 3180 i := len(dAtA) 3181 _ = i 3182 var l int 3183 _ = l 3184 if m.Desc != nil { 3185 { 3186 size, err := m.Desc.MarshalToSizedBuffer(dAtA[:i]) 3187 if err != nil { 3188 return 0, err 3189 } 3190 i -= size 3191 i = encodeVarintGrpc(dAtA, i, uint64(size)) 3192 } 3193 i-- 3194 dAtA[i] = 0xa 3195 } 3196 return len(dAtA) - i, nil 3197} 3198 3199func (m *TableDesc) Marshal() (dAtA []byte, err error) { 3200 size := m.Size() 3201 dAtA = make([]byte, size) 3202 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 3203 if err != nil { 3204 return nil, err 3205 } 3206 return dAtA[:n], nil 3207} 3208 3209func (m *TableDesc) MarshalTo(dAtA []byte) (int, error) { 3210 size := m.Size() 3211 return m.MarshalToSizedBuffer(dAtA[:size]) 3212} 3213 3214func (m *TableDesc) MarshalToSizedBuffer(dAtA []byte) (int, error) { 3215 i := len(dAtA) 3216 _ = i 3217 var l int 3218 _ = l 3219 if len(m.Tags) > 0 { 3220 for k := range m.Tags { 3221 v := m.Tags[k] 3222 baseI := i 3223 i -= len(v) 3224 copy(dAtA[i:], v) 3225 i = encodeVarintGrpc(dAtA, i, uint64(len(v))) 3226 i-- 3227 dAtA[i] = 0x12 3228 i -= len(k) 3229 copy(dAtA[i:], k) 3230 i = encodeVarintGrpc(dAtA, i, uint64(len(k))) 3231 i-- 3232 dAtA[i] = 0xa 3233 i = encodeVarintGrpc(dAtA, i, uint64(baseI-i)) 3234 i-- 3235 dAtA[i] = 0x2a 3236 } 3237 } 3238 if m.ProvisionedWrite != 0 { 3239 i = encodeVarintGrpc(dAtA, i, uint64(m.ProvisionedWrite)) 3240 i-- 3241 dAtA[i] = 0x20 3242 } 3243 if m.ProvisionedRead != 0 { 3244 i = encodeVarintGrpc(dAtA, i, uint64(m.ProvisionedRead)) 3245 i-- 3246 dAtA[i] = 0x18 3247 } 3248 if m.UseOnDemandIOMode { 3249 i-- 3250 if m.UseOnDemandIOMode { 3251 dAtA[i] = 1 3252 } else { 3253 dAtA[i] = 0 3254 } 3255 i-- 3256 dAtA[i] = 0x10 3257 } 3258 if len(m.Name) > 0 { 3259 i -= len(m.Name) 3260 copy(dAtA[i:], m.Name) 3261 i = encodeVarintGrpc(dAtA, i, uint64(len(m.Name))) 3262 i-- 3263 dAtA[i] = 0xa 3264 } 3265 return len(dAtA) - i, nil 3266} 3267 3268func (m *ListTablesResponse) Marshal() (dAtA []byte, err error) { 3269 size := m.Size() 3270 dAtA = make([]byte, size) 3271 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 3272 if err != nil { 3273 return nil, err 3274 } 3275 return dAtA[:n], nil 3276} 3277 3278func (m *ListTablesResponse) MarshalTo(dAtA []byte) (int, error) { 3279 size := m.Size() 3280 return m.MarshalToSizedBuffer(dAtA[:size]) 3281} 3282 3283func (m *ListTablesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { 3284 i := len(dAtA) 3285 _ = i 3286 var l int 3287 _ = l 3288 if len(m.TableNames) > 0 { 3289 for iNdEx := len(m.TableNames) - 1; iNdEx >= 0; iNdEx-- { 3290 i -= len(m.TableNames[iNdEx]) 3291 copy(dAtA[i:], m.TableNames[iNdEx]) 3292 i = encodeVarintGrpc(dAtA, i, uint64(len(m.TableNames[iNdEx]))) 3293 i-- 3294 dAtA[i] = 0xa 3295 } 3296 } 3297 return len(dAtA) - i, nil 3298} 3299 3300func (m *Labels) Marshal() (dAtA []byte, err error) { 3301 size := m.Size() 3302 dAtA = make([]byte, size) 3303 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 3304 if err != nil { 3305 return nil, err 3306 } 3307 return dAtA[:n], nil 3308} 3309 3310func (m *Labels) MarshalTo(dAtA []byte) (int, error) { 3311 size := m.Size() 3312 return m.MarshalToSizedBuffer(dAtA[:size]) 3313} 3314 3315func (m *Labels) MarshalToSizedBuffer(dAtA []byte) (int, error) { 3316 i := len(dAtA) 3317 _ = i 3318 var l int 3319 _ = l 3320 if len(m.Value) > 0 { 3321 i -= len(m.Value) 3322 copy(dAtA[i:], m.Value) 3323 i = encodeVarintGrpc(dAtA, i, uint64(len(m.Value))) 3324 i-- 3325 dAtA[i] = 0x12 3326 } 3327 if len(m.Name) > 0 { 3328 i -= len(m.Name) 3329 copy(dAtA[i:], m.Name) 3330 i = encodeVarintGrpc(dAtA, i, uint64(len(m.Name))) 3331 i-- 3332 dAtA[i] = 0xa 3333 } 3334 return len(dAtA) - i, nil 3335} 3336 3337func encodeVarintGrpc(dAtA []byte, offset int, v uint64) int { 3338 offset -= sovGrpc(v) 3339 base := offset 3340 for v >= 1<<7 { 3341 dAtA[offset] = uint8(v&0x7f | 0x80) 3342 v >>= 7 3343 offset++ 3344 } 3345 dAtA[offset] = uint8(v) 3346 return base 3347} 3348func (m *PutChunksRequest) Size() (n int) { 3349 if m == nil { 3350 return 0 3351 } 3352 var l int 3353 _ = l 3354 if len(m.Chunks) > 0 { 3355 for _, e := range m.Chunks { 3356 l = e.Size() 3357 n += 1 + l + sovGrpc(uint64(l)) 3358 } 3359 } 3360 return n 3361} 3362 3363func (m *GetChunksRequest) Size() (n int) { 3364 if m == nil { 3365 return 0 3366 } 3367 var l int 3368 _ = l 3369 if len(m.Chunks) > 0 { 3370 for _, e := range m.Chunks { 3371 l = e.Size() 3372 n += 1 + l + sovGrpc(uint64(l)) 3373 } 3374 } 3375 return n 3376} 3377 3378func (m *GetChunksResponse) Size() (n int) { 3379 if m == nil { 3380 return 0 3381 } 3382 var l int 3383 _ = l 3384 if len(m.Chunks) > 0 { 3385 for _, e := range m.Chunks { 3386 l = e.Size() 3387 n += 1 + l + sovGrpc(uint64(l)) 3388 } 3389 } 3390 return n 3391} 3392 3393func (m *Chunk) Size() (n int) { 3394 if m == nil { 3395 return 0 3396 } 3397 var l int 3398 _ = l 3399 l = len(m.Encoded) 3400 if l > 0 { 3401 n += 1 + l + sovGrpc(uint64(l)) 3402 } 3403 l = len(m.Key) 3404 if l > 0 { 3405 n += 1 + l + sovGrpc(uint64(l)) 3406 } 3407 l = len(m.TableName) 3408 if l > 0 { 3409 n += 1 + l + sovGrpc(uint64(l)) 3410 } 3411 return n 3412} 3413 3414func (m *ChunkID) Size() (n int) { 3415 if m == nil { 3416 return 0 3417 } 3418 var l int 3419 _ = l 3420 l = len(m.ChunkID) 3421 if l > 0 { 3422 n += 1 + l + sovGrpc(uint64(l)) 3423 } 3424 return n 3425} 3426 3427func (m *DeleteTableRequest) Size() (n int) { 3428 if m == nil { 3429 return 0 3430 } 3431 var l int 3432 _ = l 3433 l = len(m.TableName) 3434 if l > 0 { 3435 n += 1 + l + sovGrpc(uint64(l)) 3436 } 3437 return n 3438} 3439 3440func (m *DescribeTableRequest) Size() (n int) { 3441 if m == nil { 3442 return 0 3443 } 3444 var l int 3445 _ = l 3446 l = len(m.TableName) 3447 if l > 0 { 3448 n += 1 + l + sovGrpc(uint64(l)) 3449 } 3450 return n 3451} 3452 3453func (m *WriteBatch) Size() (n int) { 3454 if m == nil { 3455 return 0 3456 } 3457 var l int 3458 _ = l 3459 if len(m.Writes) > 0 { 3460 for _, e := range m.Writes { 3461 l = e.Size() 3462 n += 1 + l + sovGrpc(uint64(l)) 3463 } 3464 } 3465 if len(m.Deletes) > 0 { 3466 for _, e := range m.Deletes { 3467 l = e.Size() 3468 n += 1 + l + sovGrpc(uint64(l)) 3469 } 3470 } 3471 return n 3472} 3473 3474func (m *WriteIndexRequest) Size() (n int) { 3475 if m == nil { 3476 return 0 3477 } 3478 var l int 3479 _ = l 3480 if len(m.Writes) > 0 { 3481 for _, e := range m.Writes { 3482 l = e.Size() 3483 n += 1 + l + sovGrpc(uint64(l)) 3484 } 3485 } 3486 return n 3487} 3488 3489func (m *DeleteIndexRequest) Size() (n int) { 3490 if m == nil { 3491 return 0 3492 } 3493 var l int 3494 _ = l 3495 if len(m.Deletes) > 0 { 3496 for _, e := range m.Deletes { 3497 l = e.Size() 3498 n += 1 + l + sovGrpc(uint64(l)) 3499 } 3500 } 3501 return n 3502} 3503 3504func (m *QueryIndexResponse) Size() (n int) { 3505 if m == nil { 3506 return 0 3507 } 3508 var l int 3509 _ = l 3510 if len(m.Rows) > 0 { 3511 for _, e := range m.Rows { 3512 l = e.Size() 3513 n += 1 + l + sovGrpc(uint64(l)) 3514 } 3515 } 3516 return n 3517} 3518 3519func (m *Row) Size() (n int) { 3520 if m == nil { 3521 return 0 3522 } 3523 var l int 3524 _ = l 3525 l = len(m.RangeValue) 3526 if l > 0 { 3527 n += 1 + l + sovGrpc(uint64(l)) 3528 } 3529 l = len(m.Value) 3530 if l > 0 { 3531 n += 1 + l + sovGrpc(uint64(l)) 3532 } 3533 return n 3534} 3535 3536func (m *IndexEntry) Size() (n int) { 3537 if m == nil { 3538 return 0 3539 } 3540 var l int 3541 _ = l 3542 l = len(m.TableName) 3543 if l > 0 { 3544 n += 1 + l + sovGrpc(uint64(l)) 3545 } 3546 l = len(m.HashValue) 3547 if l > 0 { 3548 n += 1 + l + sovGrpc(uint64(l)) 3549 } 3550 l = len(m.RangeValue) 3551 if l > 0 { 3552 n += 1 + l + sovGrpc(uint64(l)) 3553 } 3554 l = len(m.Value) 3555 if l > 0 { 3556 n += 1 + l + sovGrpc(uint64(l)) 3557 } 3558 return n 3559} 3560 3561func (m *QueryIndexRequest) Size() (n int) { 3562 if m == nil { 3563 return 0 3564 } 3565 var l int 3566 _ = l 3567 l = len(m.TableName) 3568 if l > 0 { 3569 n += 1 + l + sovGrpc(uint64(l)) 3570 } 3571 l = len(m.HashValue) 3572 if l > 0 { 3573 n += 1 + l + sovGrpc(uint64(l)) 3574 } 3575 l = len(m.RangeValuePrefix) 3576 if l > 0 { 3577 n += 1 + l + sovGrpc(uint64(l)) 3578 } 3579 l = len(m.RangeValueStart) 3580 if l > 0 { 3581 n += 1 + l + sovGrpc(uint64(l)) 3582 } 3583 l = len(m.ValueEqual) 3584 if l > 0 { 3585 n += 1 + l + sovGrpc(uint64(l)) 3586 } 3587 if m.Immutable { 3588 n += 2 3589 } 3590 return n 3591} 3592 3593func (m *UpdateTableRequest) Size() (n int) { 3594 if m == nil { 3595 return 0 3596 } 3597 var l int 3598 _ = l 3599 if m.Current != nil { 3600 l = m.Current.Size() 3601 n += 1 + l + sovGrpc(uint64(l)) 3602 } 3603 if m.Expected != nil { 3604 l = m.Expected.Size() 3605 n += 1 + l + sovGrpc(uint64(l)) 3606 } 3607 return n 3608} 3609 3610func (m *DescribeTableResponse) Size() (n int) { 3611 if m == nil { 3612 return 0 3613 } 3614 var l int 3615 _ = l 3616 if m.Desc != nil { 3617 l = m.Desc.Size() 3618 n += 1 + l + sovGrpc(uint64(l)) 3619 } 3620 if m.IsActive { 3621 n += 2 3622 } 3623 return n 3624} 3625 3626func (m *CreateTableRequest) Size() (n int) { 3627 if m == nil { 3628 return 0 3629 } 3630 var l int 3631 _ = l 3632 if m.Desc != nil { 3633 l = m.Desc.Size() 3634 n += 1 + l + sovGrpc(uint64(l)) 3635 } 3636 return n 3637} 3638 3639func (m *TableDesc) Size() (n int) { 3640 if m == nil { 3641 return 0 3642 } 3643 var l int 3644 _ = l 3645 l = len(m.Name) 3646 if l > 0 { 3647 n += 1 + l + sovGrpc(uint64(l)) 3648 } 3649 if m.UseOnDemandIOMode { 3650 n += 2 3651 } 3652 if m.ProvisionedRead != 0 { 3653 n += 1 + sovGrpc(uint64(m.ProvisionedRead)) 3654 } 3655 if m.ProvisionedWrite != 0 { 3656 n += 1 + sovGrpc(uint64(m.ProvisionedWrite)) 3657 } 3658 if len(m.Tags) > 0 { 3659 for k, v := range m.Tags { 3660 _ = k 3661 _ = v 3662 mapEntrySize := 1 + len(k) + sovGrpc(uint64(len(k))) + 1 + len(v) + sovGrpc(uint64(len(v))) 3663 n += mapEntrySize + 1 + sovGrpc(uint64(mapEntrySize)) 3664 } 3665 } 3666 return n 3667} 3668 3669func (m *ListTablesResponse) Size() (n int) { 3670 if m == nil { 3671 return 0 3672 } 3673 var l int 3674 _ = l 3675 if len(m.TableNames) > 0 { 3676 for _, s := range m.TableNames { 3677 l = len(s) 3678 n += 1 + l + sovGrpc(uint64(l)) 3679 } 3680 } 3681 return n 3682} 3683 3684func (m *Labels) Size() (n int) { 3685 if m == nil { 3686 return 0 3687 } 3688 var l int 3689 _ = l 3690 l = len(m.Name) 3691 if l > 0 { 3692 n += 1 + l + sovGrpc(uint64(l)) 3693 } 3694 l = len(m.Value) 3695 if l > 0 { 3696 n += 1 + l + sovGrpc(uint64(l)) 3697 } 3698 return n 3699} 3700 3701func sovGrpc(x uint64) (n int) { 3702 return (math_bits.Len64(x|1) + 6) / 7 3703} 3704func sozGrpc(x uint64) (n int) { 3705 return sovGrpc(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 3706} 3707func (this *PutChunksRequest) String() string { 3708 if this == nil { 3709 return "nil" 3710 } 3711 repeatedStringForChunks := "[]*Chunk{" 3712 for _, f := range this.Chunks { 3713 repeatedStringForChunks += strings.Replace(f.String(), "Chunk", "Chunk", 1) + "," 3714 } 3715 repeatedStringForChunks += "}" 3716 s := strings.Join([]string{`&PutChunksRequest{`, 3717 `Chunks:` + repeatedStringForChunks + `,`, 3718 `}`, 3719 }, "") 3720 return s 3721} 3722func (this *GetChunksRequest) String() string { 3723 if this == nil { 3724 return "nil" 3725 } 3726 repeatedStringForChunks := "[]*Chunk{" 3727 for _, f := range this.Chunks { 3728 repeatedStringForChunks += strings.Replace(f.String(), "Chunk", "Chunk", 1) + "," 3729 } 3730 repeatedStringForChunks += "}" 3731 s := strings.Join([]string{`&GetChunksRequest{`, 3732 `Chunks:` + repeatedStringForChunks + `,`, 3733 `}`, 3734 }, "") 3735 return s 3736} 3737func (this *GetChunksResponse) String() string { 3738 if this == nil { 3739 return "nil" 3740 } 3741 repeatedStringForChunks := "[]*Chunk{" 3742 for _, f := range this.Chunks { 3743 repeatedStringForChunks += strings.Replace(f.String(), "Chunk", "Chunk", 1) + "," 3744 } 3745 repeatedStringForChunks += "}" 3746 s := strings.Join([]string{`&GetChunksResponse{`, 3747 `Chunks:` + repeatedStringForChunks + `,`, 3748 `}`, 3749 }, "") 3750 return s 3751} 3752func (this *Chunk) String() string { 3753 if this == nil { 3754 return "nil" 3755 } 3756 s := strings.Join([]string{`&Chunk{`, 3757 `Encoded:` + fmt.Sprintf("%v", this.Encoded) + `,`, 3758 `Key:` + fmt.Sprintf("%v", this.Key) + `,`, 3759 `TableName:` + fmt.Sprintf("%v", this.TableName) + `,`, 3760 `}`, 3761 }, "") 3762 return s 3763} 3764func (this *ChunkID) String() string { 3765 if this == nil { 3766 return "nil" 3767 } 3768 s := strings.Join([]string{`&ChunkID{`, 3769 `ChunkID:` + fmt.Sprintf("%v", this.ChunkID) + `,`, 3770 `}`, 3771 }, "") 3772 return s 3773} 3774func (this *DeleteTableRequest) String() string { 3775 if this == nil { 3776 return "nil" 3777 } 3778 s := strings.Join([]string{`&DeleteTableRequest{`, 3779 `TableName:` + fmt.Sprintf("%v", this.TableName) + `,`, 3780 `}`, 3781 }, "") 3782 return s 3783} 3784func (this *DescribeTableRequest) String() string { 3785 if this == nil { 3786 return "nil" 3787 } 3788 s := strings.Join([]string{`&DescribeTableRequest{`, 3789 `TableName:` + fmt.Sprintf("%v", this.TableName) + `,`, 3790 `}`, 3791 }, "") 3792 return s 3793} 3794func (this *WriteBatch) String() string { 3795 if this == nil { 3796 return "nil" 3797 } 3798 repeatedStringForWrites := "[]*IndexEntry{" 3799 for _, f := range this.Writes { 3800 repeatedStringForWrites += strings.Replace(f.String(), "IndexEntry", "IndexEntry", 1) + "," 3801 } 3802 repeatedStringForWrites += "}" 3803 repeatedStringForDeletes := "[]*IndexEntry{" 3804 for _, f := range this.Deletes { 3805 repeatedStringForDeletes += strings.Replace(f.String(), "IndexEntry", "IndexEntry", 1) + "," 3806 } 3807 repeatedStringForDeletes += "}" 3808 s := strings.Join([]string{`&WriteBatch{`, 3809 `Writes:` + repeatedStringForWrites + `,`, 3810 `Deletes:` + repeatedStringForDeletes + `,`, 3811 `}`, 3812 }, "") 3813 return s 3814} 3815func (this *WriteIndexRequest) String() string { 3816 if this == nil { 3817 return "nil" 3818 } 3819 repeatedStringForWrites := "[]*IndexEntry{" 3820 for _, f := range this.Writes { 3821 repeatedStringForWrites += strings.Replace(f.String(), "IndexEntry", "IndexEntry", 1) + "," 3822 } 3823 repeatedStringForWrites += "}" 3824 s := strings.Join([]string{`&WriteIndexRequest{`, 3825 `Writes:` + repeatedStringForWrites + `,`, 3826 `}`, 3827 }, "") 3828 return s 3829} 3830func (this *DeleteIndexRequest) String() string { 3831 if this == nil { 3832 return "nil" 3833 } 3834 repeatedStringForDeletes := "[]*IndexEntry{" 3835 for _, f := range this.Deletes { 3836 repeatedStringForDeletes += strings.Replace(f.String(), "IndexEntry", "IndexEntry", 1) + "," 3837 } 3838 repeatedStringForDeletes += "}" 3839 s := strings.Join([]string{`&DeleteIndexRequest{`, 3840 `Deletes:` + repeatedStringForDeletes + `,`, 3841 `}`, 3842 }, "") 3843 return s 3844} 3845func (this *QueryIndexResponse) String() string { 3846 if this == nil { 3847 return "nil" 3848 } 3849 repeatedStringForRows := "[]*Row{" 3850 for _, f := range this.Rows { 3851 repeatedStringForRows += strings.Replace(f.String(), "Row", "Row", 1) + "," 3852 } 3853 repeatedStringForRows += "}" 3854 s := strings.Join([]string{`&QueryIndexResponse{`, 3855 `Rows:` + repeatedStringForRows + `,`, 3856 `}`, 3857 }, "") 3858 return s 3859} 3860func (this *Row) String() string { 3861 if this == nil { 3862 return "nil" 3863 } 3864 s := strings.Join([]string{`&Row{`, 3865 `RangeValue:` + fmt.Sprintf("%v", this.RangeValue) + `,`, 3866 `Value:` + fmt.Sprintf("%v", this.Value) + `,`, 3867 `}`, 3868 }, "") 3869 return s 3870} 3871func (this *IndexEntry) String() string { 3872 if this == nil { 3873 return "nil" 3874 } 3875 s := strings.Join([]string{`&IndexEntry{`, 3876 `TableName:` + fmt.Sprintf("%v", this.TableName) + `,`, 3877 `HashValue:` + fmt.Sprintf("%v", this.HashValue) + `,`, 3878 `RangeValue:` + fmt.Sprintf("%v", this.RangeValue) + `,`, 3879 `Value:` + fmt.Sprintf("%v", this.Value) + `,`, 3880 `}`, 3881 }, "") 3882 return s 3883} 3884func (this *QueryIndexRequest) String() string { 3885 if this == nil { 3886 return "nil" 3887 } 3888 s := strings.Join([]string{`&QueryIndexRequest{`, 3889 `TableName:` + fmt.Sprintf("%v", this.TableName) + `,`, 3890 `HashValue:` + fmt.Sprintf("%v", this.HashValue) + `,`, 3891 `RangeValuePrefix:` + fmt.Sprintf("%v", this.RangeValuePrefix) + `,`, 3892 `RangeValueStart:` + fmt.Sprintf("%v", this.RangeValueStart) + `,`, 3893 `ValueEqual:` + fmt.Sprintf("%v", this.ValueEqual) + `,`, 3894 `Immutable:` + fmt.Sprintf("%v", this.Immutable) + `,`, 3895 `}`, 3896 }, "") 3897 return s 3898} 3899func (this *UpdateTableRequest) String() string { 3900 if this == nil { 3901 return "nil" 3902 } 3903 s := strings.Join([]string{`&UpdateTableRequest{`, 3904 `Current:` + strings.Replace(this.Current.String(), "TableDesc", "TableDesc", 1) + `,`, 3905 `Expected:` + strings.Replace(this.Expected.String(), "TableDesc", "TableDesc", 1) + `,`, 3906 `}`, 3907 }, "") 3908 return s 3909} 3910func (this *DescribeTableResponse) String() string { 3911 if this == nil { 3912 return "nil" 3913 } 3914 s := strings.Join([]string{`&DescribeTableResponse{`, 3915 `Desc:` + strings.Replace(this.Desc.String(), "TableDesc", "TableDesc", 1) + `,`, 3916 `IsActive:` + fmt.Sprintf("%v", this.IsActive) + `,`, 3917 `}`, 3918 }, "") 3919 return s 3920} 3921func (this *CreateTableRequest) String() string { 3922 if this == nil { 3923 return "nil" 3924 } 3925 s := strings.Join([]string{`&CreateTableRequest{`, 3926 `Desc:` + strings.Replace(this.Desc.String(), "TableDesc", "TableDesc", 1) + `,`, 3927 `}`, 3928 }, "") 3929 return s 3930} 3931func (this *TableDesc) String() string { 3932 if this == nil { 3933 return "nil" 3934 } 3935 keysForTags := make([]string, 0, len(this.Tags)) 3936 for k, _ := range this.Tags { 3937 keysForTags = append(keysForTags, k) 3938 } 3939 github_com_gogo_protobuf_sortkeys.Strings(keysForTags) 3940 mapStringForTags := "map[string]string{" 3941 for _, k := range keysForTags { 3942 mapStringForTags += fmt.Sprintf("%v: %v,", k, this.Tags[k]) 3943 } 3944 mapStringForTags += "}" 3945 s := strings.Join([]string{`&TableDesc{`, 3946 `Name:` + fmt.Sprintf("%v", this.Name) + `,`, 3947 `UseOnDemandIOMode:` + fmt.Sprintf("%v", this.UseOnDemandIOMode) + `,`, 3948 `ProvisionedRead:` + fmt.Sprintf("%v", this.ProvisionedRead) + `,`, 3949 `ProvisionedWrite:` + fmt.Sprintf("%v", this.ProvisionedWrite) + `,`, 3950 `Tags:` + mapStringForTags + `,`, 3951 `}`, 3952 }, "") 3953 return s 3954} 3955func (this *ListTablesResponse) String() string { 3956 if this == nil { 3957 return "nil" 3958 } 3959 s := strings.Join([]string{`&ListTablesResponse{`, 3960 `TableNames:` + fmt.Sprintf("%v", this.TableNames) + `,`, 3961 `}`, 3962 }, "") 3963 return s 3964} 3965func (this *Labels) String() string { 3966 if this == nil { 3967 return "nil" 3968 } 3969 s := strings.Join([]string{`&Labels{`, 3970 `Name:` + fmt.Sprintf("%v", this.Name) + `,`, 3971 `Value:` + fmt.Sprintf("%v", this.Value) + `,`, 3972 `}`, 3973 }, "") 3974 return s 3975} 3976func valueToStringGrpc(v interface{}) string { 3977 rv := reflect.ValueOf(v) 3978 if rv.IsNil() { 3979 return "nil" 3980 } 3981 pv := reflect.Indirect(rv).Interface() 3982 return fmt.Sprintf("*%v", pv) 3983} 3984func (m *PutChunksRequest) Unmarshal(dAtA []byte) error { 3985 l := len(dAtA) 3986 iNdEx := 0 3987 for iNdEx < l { 3988 preIndex := iNdEx 3989 var wire uint64 3990 for shift := uint(0); ; shift += 7 { 3991 if shift >= 64 { 3992 return ErrIntOverflowGrpc 3993 } 3994 if iNdEx >= l { 3995 return io.ErrUnexpectedEOF 3996 } 3997 b := dAtA[iNdEx] 3998 iNdEx++ 3999 wire |= uint64(b&0x7F) << shift 4000 if b < 0x80 { 4001 break 4002 } 4003 } 4004 fieldNum := int32(wire >> 3) 4005 wireType := int(wire & 0x7) 4006 if wireType == 4 { 4007 return fmt.Errorf("proto: PutChunksRequest: wiretype end group for non-group") 4008 } 4009 if fieldNum <= 0 { 4010 return fmt.Errorf("proto: PutChunksRequest: illegal tag %d (wire type %d)", fieldNum, wire) 4011 } 4012 switch fieldNum { 4013 case 1: 4014 if wireType != 2 { 4015 return fmt.Errorf("proto: wrong wireType = %d for field Chunks", wireType) 4016 } 4017 var msglen int 4018 for shift := uint(0); ; shift += 7 { 4019 if shift >= 64 { 4020 return ErrIntOverflowGrpc 4021 } 4022 if iNdEx >= l { 4023 return io.ErrUnexpectedEOF 4024 } 4025 b := dAtA[iNdEx] 4026 iNdEx++ 4027 msglen |= int(b&0x7F) << shift 4028 if b < 0x80 { 4029 break 4030 } 4031 } 4032 if msglen < 0 { 4033 return ErrInvalidLengthGrpc 4034 } 4035 postIndex := iNdEx + msglen 4036 if postIndex < 0 { 4037 return ErrInvalidLengthGrpc 4038 } 4039 if postIndex > l { 4040 return io.ErrUnexpectedEOF 4041 } 4042 m.Chunks = append(m.Chunks, &Chunk{}) 4043 if err := m.Chunks[len(m.Chunks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 4044 return err 4045 } 4046 iNdEx = postIndex 4047 default: 4048 iNdEx = preIndex 4049 skippy, err := skipGrpc(dAtA[iNdEx:]) 4050 if err != nil { 4051 return err 4052 } 4053 if skippy < 0 { 4054 return ErrInvalidLengthGrpc 4055 } 4056 if (iNdEx + skippy) < 0 { 4057 return ErrInvalidLengthGrpc 4058 } 4059 if (iNdEx + skippy) > l { 4060 return io.ErrUnexpectedEOF 4061 } 4062 iNdEx += skippy 4063 } 4064 } 4065 4066 if iNdEx > l { 4067 return io.ErrUnexpectedEOF 4068 } 4069 return nil 4070} 4071func (m *GetChunksRequest) Unmarshal(dAtA []byte) error { 4072 l := len(dAtA) 4073 iNdEx := 0 4074 for iNdEx < l { 4075 preIndex := iNdEx 4076 var wire uint64 4077 for shift := uint(0); ; shift += 7 { 4078 if shift >= 64 { 4079 return ErrIntOverflowGrpc 4080 } 4081 if iNdEx >= l { 4082 return io.ErrUnexpectedEOF 4083 } 4084 b := dAtA[iNdEx] 4085 iNdEx++ 4086 wire |= uint64(b&0x7F) << shift 4087 if b < 0x80 { 4088 break 4089 } 4090 } 4091 fieldNum := int32(wire >> 3) 4092 wireType := int(wire & 0x7) 4093 if wireType == 4 { 4094 return fmt.Errorf("proto: GetChunksRequest: wiretype end group for non-group") 4095 } 4096 if fieldNum <= 0 { 4097 return fmt.Errorf("proto: GetChunksRequest: illegal tag %d (wire type %d)", fieldNum, wire) 4098 } 4099 switch fieldNum { 4100 case 1: 4101 if wireType != 2 { 4102 return fmt.Errorf("proto: wrong wireType = %d for field Chunks", wireType) 4103 } 4104 var msglen int 4105 for shift := uint(0); ; shift += 7 { 4106 if shift >= 64 { 4107 return ErrIntOverflowGrpc 4108 } 4109 if iNdEx >= l { 4110 return io.ErrUnexpectedEOF 4111 } 4112 b := dAtA[iNdEx] 4113 iNdEx++ 4114 msglen |= int(b&0x7F) << shift 4115 if b < 0x80 { 4116 break 4117 } 4118 } 4119 if msglen < 0 { 4120 return ErrInvalidLengthGrpc 4121 } 4122 postIndex := iNdEx + msglen 4123 if postIndex < 0 { 4124 return ErrInvalidLengthGrpc 4125 } 4126 if postIndex > l { 4127 return io.ErrUnexpectedEOF 4128 } 4129 m.Chunks = append(m.Chunks, &Chunk{}) 4130 if err := m.Chunks[len(m.Chunks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 4131 return err 4132 } 4133 iNdEx = postIndex 4134 default: 4135 iNdEx = preIndex 4136 skippy, err := skipGrpc(dAtA[iNdEx:]) 4137 if err != nil { 4138 return err 4139 } 4140 if skippy < 0 { 4141 return ErrInvalidLengthGrpc 4142 } 4143 if (iNdEx + skippy) < 0 { 4144 return ErrInvalidLengthGrpc 4145 } 4146 if (iNdEx + skippy) > l { 4147 return io.ErrUnexpectedEOF 4148 } 4149 iNdEx += skippy 4150 } 4151 } 4152 4153 if iNdEx > l { 4154 return io.ErrUnexpectedEOF 4155 } 4156 return nil 4157} 4158func (m *GetChunksResponse) Unmarshal(dAtA []byte) error { 4159 l := len(dAtA) 4160 iNdEx := 0 4161 for iNdEx < l { 4162 preIndex := iNdEx 4163 var wire uint64 4164 for shift := uint(0); ; shift += 7 { 4165 if shift >= 64 { 4166 return ErrIntOverflowGrpc 4167 } 4168 if iNdEx >= l { 4169 return io.ErrUnexpectedEOF 4170 } 4171 b := dAtA[iNdEx] 4172 iNdEx++ 4173 wire |= uint64(b&0x7F) << shift 4174 if b < 0x80 { 4175 break 4176 } 4177 } 4178 fieldNum := int32(wire >> 3) 4179 wireType := int(wire & 0x7) 4180 if wireType == 4 { 4181 return fmt.Errorf("proto: GetChunksResponse: wiretype end group for non-group") 4182 } 4183 if fieldNum <= 0 { 4184 return fmt.Errorf("proto: GetChunksResponse: illegal tag %d (wire type %d)", fieldNum, wire) 4185 } 4186 switch fieldNum { 4187 case 1: 4188 if wireType != 2 { 4189 return fmt.Errorf("proto: wrong wireType = %d for field Chunks", wireType) 4190 } 4191 var msglen int 4192 for shift := uint(0); ; shift += 7 { 4193 if shift >= 64 { 4194 return ErrIntOverflowGrpc 4195 } 4196 if iNdEx >= l { 4197 return io.ErrUnexpectedEOF 4198 } 4199 b := dAtA[iNdEx] 4200 iNdEx++ 4201 msglen |= int(b&0x7F) << shift 4202 if b < 0x80 { 4203 break 4204 } 4205 } 4206 if msglen < 0 { 4207 return ErrInvalidLengthGrpc 4208 } 4209 postIndex := iNdEx + msglen 4210 if postIndex < 0 { 4211 return ErrInvalidLengthGrpc 4212 } 4213 if postIndex > l { 4214 return io.ErrUnexpectedEOF 4215 } 4216 m.Chunks = append(m.Chunks, &Chunk{}) 4217 if err := m.Chunks[len(m.Chunks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 4218 return err 4219 } 4220 iNdEx = postIndex 4221 default: 4222 iNdEx = preIndex 4223 skippy, err := skipGrpc(dAtA[iNdEx:]) 4224 if err != nil { 4225 return err 4226 } 4227 if skippy < 0 { 4228 return ErrInvalidLengthGrpc 4229 } 4230 if (iNdEx + skippy) < 0 { 4231 return ErrInvalidLengthGrpc 4232 } 4233 if (iNdEx + skippy) > l { 4234 return io.ErrUnexpectedEOF 4235 } 4236 iNdEx += skippy 4237 } 4238 } 4239 4240 if iNdEx > l { 4241 return io.ErrUnexpectedEOF 4242 } 4243 return nil 4244} 4245func (m *Chunk) Unmarshal(dAtA []byte) error { 4246 l := len(dAtA) 4247 iNdEx := 0 4248 for iNdEx < l { 4249 preIndex := iNdEx 4250 var wire uint64 4251 for shift := uint(0); ; shift += 7 { 4252 if shift >= 64 { 4253 return ErrIntOverflowGrpc 4254 } 4255 if iNdEx >= l { 4256 return io.ErrUnexpectedEOF 4257 } 4258 b := dAtA[iNdEx] 4259 iNdEx++ 4260 wire |= uint64(b&0x7F) << shift 4261 if b < 0x80 { 4262 break 4263 } 4264 } 4265 fieldNum := int32(wire >> 3) 4266 wireType := int(wire & 0x7) 4267 if wireType == 4 { 4268 return fmt.Errorf("proto: Chunk: wiretype end group for non-group") 4269 } 4270 if fieldNum <= 0 { 4271 return fmt.Errorf("proto: Chunk: illegal tag %d (wire type %d)", fieldNum, wire) 4272 } 4273 switch fieldNum { 4274 case 1: 4275 if wireType != 2 { 4276 return fmt.Errorf("proto: wrong wireType = %d for field Encoded", wireType) 4277 } 4278 var byteLen int 4279 for shift := uint(0); ; shift += 7 { 4280 if shift >= 64 { 4281 return ErrIntOverflowGrpc 4282 } 4283 if iNdEx >= l { 4284 return io.ErrUnexpectedEOF 4285 } 4286 b := dAtA[iNdEx] 4287 iNdEx++ 4288 byteLen |= int(b&0x7F) << shift 4289 if b < 0x80 { 4290 break 4291 } 4292 } 4293 if byteLen < 0 { 4294 return ErrInvalidLengthGrpc 4295 } 4296 postIndex := iNdEx + byteLen 4297 if postIndex < 0 { 4298 return ErrInvalidLengthGrpc 4299 } 4300 if postIndex > l { 4301 return io.ErrUnexpectedEOF 4302 } 4303 m.Encoded = append(m.Encoded[:0], dAtA[iNdEx:postIndex]...) 4304 if m.Encoded == nil { 4305 m.Encoded = []byte{} 4306 } 4307 iNdEx = postIndex 4308 case 2: 4309 if wireType != 2 { 4310 return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) 4311 } 4312 var stringLen uint64 4313 for shift := uint(0); ; shift += 7 { 4314 if shift >= 64 { 4315 return ErrIntOverflowGrpc 4316 } 4317 if iNdEx >= l { 4318 return io.ErrUnexpectedEOF 4319 } 4320 b := dAtA[iNdEx] 4321 iNdEx++ 4322 stringLen |= uint64(b&0x7F) << shift 4323 if b < 0x80 { 4324 break 4325 } 4326 } 4327 intStringLen := int(stringLen) 4328 if intStringLen < 0 { 4329 return ErrInvalidLengthGrpc 4330 } 4331 postIndex := iNdEx + intStringLen 4332 if postIndex < 0 { 4333 return ErrInvalidLengthGrpc 4334 } 4335 if postIndex > l { 4336 return io.ErrUnexpectedEOF 4337 } 4338 m.Key = string(dAtA[iNdEx:postIndex]) 4339 iNdEx = postIndex 4340 case 3: 4341 if wireType != 2 { 4342 return fmt.Errorf("proto: wrong wireType = %d for field TableName", wireType) 4343 } 4344 var stringLen uint64 4345 for shift := uint(0); ; shift += 7 { 4346 if shift >= 64 { 4347 return ErrIntOverflowGrpc 4348 } 4349 if iNdEx >= l { 4350 return io.ErrUnexpectedEOF 4351 } 4352 b := dAtA[iNdEx] 4353 iNdEx++ 4354 stringLen |= uint64(b&0x7F) << shift 4355 if b < 0x80 { 4356 break 4357 } 4358 } 4359 intStringLen := int(stringLen) 4360 if intStringLen < 0 { 4361 return ErrInvalidLengthGrpc 4362 } 4363 postIndex := iNdEx + intStringLen 4364 if postIndex < 0 { 4365 return ErrInvalidLengthGrpc 4366 } 4367 if postIndex > l { 4368 return io.ErrUnexpectedEOF 4369 } 4370 m.TableName = string(dAtA[iNdEx:postIndex]) 4371 iNdEx = postIndex 4372 default: 4373 iNdEx = preIndex 4374 skippy, err := skipGrpc(dAtA[iNdEx:]) 4375 if err != nil { 4376 return err 4377 } 4378 if skippy < 0 { 4379 return ErrInvalidLengthGrpc 4380 } 4381 if (iNdEx + skippy) < 0 { 4382 return ErrInvalidLengthGrpc 4383 } 4384 if (iNdEx + skippy) > l { 4385 return io.ErrUnexpectedEOF 4386 } 4387 iNdEx += skippy 4388 } 4389 } 4390 4391 if iNdEx > l { 4392 return io.ErrUnexpectedEOF 4393 } 4394 return nil 4395} 4396func (m *ChunkID) Unmarshal(dAtA []byte) error { 4397 l := len(dAtA) 4398 iNdEx := 0 4399 for iNdEx < l { 4400 preIndex := iNdEx 4401 var wire uint64 4402 for shift := uint(0); ; shift += 7 { 4403 if shift >= 64 { 4404 return ErrIntOverflowGrpc 4405 } 4406 if iNdEx >= l { 4407 return io.ErrUnexpectedEOF 4408 } 4409 b := dAtA[iNdEx] 4410 iNdEx++ 4411 wire |= uint64(b&0x7F) << shift 4412 if b < 0x80 { 4413 break 4414 } 4415 } 4416 fieldNum := int32(wire >> 3) 4417 wireType := int(wire & 0x7) 4418 if wireType == 4 { 4419 return fmt.Errorf("proto: ChunkID: wiretype end group for non-group") 4420 } 4421 if fieldNum <= 0 { 4422 return fmt.Errorf("proto: ChunkID: illegal tag %d (wire type %d)", fieldNum, wire) 4423 } 4424 switch fieldNum { 4425 case 1: 4426 if wireType != 2 { 4427 return fmt.Errorf("proto: wrong wireType = %d for field ChunkID", wireType) 4428 } 4429 var stringLen uint64 4430 for shift := uint(0); ; shift += 7 { 4431 if shift >= 64 { 4432 return ErrIntOverflowGrpc 4433 } 4434 if iNdEx >= l { 4435 return io.ErrUnexpectedEOF 4436 } 4437 b := dAtA[iNdEx] 4438 iNdEx++ 4439 stringLen |= uint64(b&0x7F) << shift 4440 if b < 0x80 { 4441 break 4442 } 4443 } 4444 intStringLen := int(stringLen) 4445 if intStringLen < 0 { 4446 return ErrInvalidLengthGrpc 4447 } 4448 postIndex := iNdEx + intStringLen 4449 if postIndex < 0 { 4450 return ErrInvalidLengthGrpc 4451 } 4452 if postIndex > l { 4453 return io.ErrUnexpectedEOF 4454 } 4455 m.ChunkID = string(dAtA[iNdEx:postIndex]) 4456 iNdEx = postIndex 4457 default: 4458 iNdEx = preIndex 4459 skippy, err := skipGrpc(dAtA[iNdEx:]) 4460 if err != nil { 4461 return err 4462 } 4463 if skippy < 0 { 4464 return ErrInvalidLengthGrpc 4465 } 4466 if (iNdEx + skippy) < 0 { 4467 return ErrInvalidLengthGrpc 4468 } 4469 if (iNdEx + skippy) > l { 4470 return io.ErrUnexpectedEOF 4471 } 4472 iNdEx += skippy 4473 } 4474 } 4475 4476 if iNdEx > l { 4477 return io.ErrUnexpectedEOF 4478 } 4479 return nil 4480} 4481func (m *DeleteTableRequest) Unmarshal(dAtA []byte) error { 4482 l := len(dAtA) 4483 iNdEx := 0 4484 for iNdEx < l { 4485 preIndex := iNdEx 4486 var wire uint64 4487 for shift := uint(0); ; shift += 7 { 4488 if shift >= 64 { 4489 return ErrIntOverflowGrpc 4490 } 4491 if iNdEx >= l { 4492 return io.ErrUnexpectedEOF 4493 } 4494 b := dAtA[iNdEx] 4495 iNdEx++ 4496 wire |= uint64(b&0x7F) << shift 4497 if b < 0x80 { 4498 break 4499 } 4500 } 4501 fieldNum := int32(wire >> 3) 4502 wireType := int(wire & 0x7) 4503 if wireType == 4 { 4504 return fmt.Errorf("proto: DeleteTableRequest: wiretype end group for non-group") 4505 } 4506 if fieldNum <= 0 { 4507 return fmt.Errorf("proto: DeleteTableRequest: illegal tag %d (wire type %d)", fieldNum, wire) 4508 } 4509 switch fieldNum { 4510 case 1: 4511 if wireType != 2 { 4512 return fmt.Errorf("proto: wrong wireType = %d for field TableName", wireType) 4513 } 4514 var stringLen uint64 4515 for shift := uint(0); ; shift += 7 { 4516 if shift >= 64 { 4517 return ErrIntOverflowGrpc 4518 } 4519 if iNdEx >= l { 4520 return io.ErrUnexpectedEOF 4521 } 4522 b := dAtA[iNdEx] 4523 iNdEx++ 4524 stringLen |= uint64(b&0x7F) << shift 4525 if b < 0x80 { 4526 break 4527 } 4528 } 4529 intStringLen := int(stringLen) 4530 if intStringLen < 0 { 4531 return ErrInvalidLengthGrpc 4532 } 4533 postIndex := iNdEx + intStringLen 4534 if postIndex < 0 { 4535 return ErrInvalidLengthGrpc 4536 } 4537 if postIndex > l { 4538 return io.ErrUnexpectedEOF 4539 } 4540 m.TableName = string(dAtA[iNdEx:postIndex]) 4541 iNdEx = postIndex 4542 default: 4543 iNdEx = preIndex 4544 skippy, err := skipGrpc(dAtA[iNdEx:]) 4545 if err != nil { 4546 return err 4547 } 4548 if skippy < 0 { 4549 return ErrInvalidLengthGrpc 4550 } 4551 if (iNdEx + skippy) < 0 { 4552 return ErrInvalidLengthGrpc 4553 } 4554 if (iNdEx + skippy) > l { 4555 return io.ErrUnexpectedEOF 4556 } 4557 iNdEx += skippy 4558 } 4559 } 4560 4561 if iNdEx > l { 4562 return io.ErrUnexpectedEOF 4563 } 4564 return nil 4565} 4566func (m *DescribeTableRequest) Unmarshal(dAtA []byte) error { 4567 l := len(dAtA) 4568 iNdEx := 0 4569 for iNdEx < l { 4570 preIndex := iNdEx 4571 var wire uint64 4572 for shift := uint(0); ; shift += 7 { 4573 if shift >= 64 { 4574 return ErrIntOverflowGrpc 4575 } 4576 if iNdEx >= l { 4577 return io.ErrUnexpectedEOF 4578 } 4579 b := dAtA[iNdEx] 4580 iNdEx++ 4581 wire |= uint64(b&0x7F) << shift 4582 if b < 0x80 { 4583 break 4584 } 4585 } 4586 fieldNum := int32(wire >> 3) 4587 wireType := int(wire & 0x7) 4588 if wireType == 4 { 4589 return fmt.Errorf("proto: DescribeTableRequest: wiretype end group for non-group") 4590 } 4591 if fieldNum <= 0 { 4592 return fmt.Errorf("proto: DescribeTableRequest: illegal tag %d (wire type %d)", fieldNum, wire) 4593 } 4594 switch fieldNum { 4595 case 1: 4596 if wireType != 2 { 4597 return fmt.Errorf("proto: wrong wireType = %d for field TableName", wireType) 4598 } 4599 var stringLen uint64 4600 for shift := uint(0); ; shift += 7 { 4601 if shift >= 64 { 4602 return ErrIntOverflowGrpc 4603 } 4604 if iNdEx >= l { 4605 return io.ErrUnexpectedEOF 4606 } 4607 b := dAtA[iNdEx] 4608 iNdEx++ 4609 stringLen |= uint64(b&0x7F) << shift 4610 if b < 0x80 { 4611 break 4612 } 4613 } 4614 intStringLen := int(stringLen) 4615 if intStringLen < 0 { 4616 return ErrInvalidLengthGrpc 4617 } 4618 postIndex := iNdEx + intStringLen 4619 if postIndex < 0 { 4620 return ErrInvalidLengthGrpc 4621 } 4622 if postIndex > l { 4623 return io.ErrUnexpectedEOF 4624 } 4625 m.TableName = string(dAtA[iNdEx:postIndex]) 4626 iNdEx = postIndex 4627 default: 4628 iNdEx = preIndex 4629 skippy, err := skipGrpc(dAtA[iNdEx:]) 4630 if err != nil { 4631 return err 4632 } 4633 if skippy < 0 { 4634 return ErrInvalidLengthGrpc 4635 } 4636 if (iNdEx + skippy) < 0 { 4637 return ErrInvalidLengthGrpc 4638 } 4639 if (iNdEx + skippy) > l { 4640 return io.ErrUnexpectedEOF 4641 } 4642 iNdEx += skippy 4643 } 4644 } 4645 4646 if iNdEx > l { 4647 return io.ErrUnexpectedEOF 4648 } 4649 return nil 4650} 4651func (m *WriteBatch) Unmarshal(dAtA []byte) error { 4652 l := len(dAtA) 4653 iNdEx := 0 4654 for iNdEx < l { 4655 preIndex := iNdEx 4656 var wire uint64 4657 for shift := uint(0); ; shift += 7 { 4658 if shift >= 64 { 4659 return ErrIntOverflowGrpc 4660 } 4661 if iNdEx >= l { 4662 return io.ErrUnexpectedEOF 4663 } 4664 b := dAtA[iNdEx] 4665 iNdEx++ 4666 wire |= uint64(b&0x7F) << shift 4667 if b < 0x80 { 4668 break 4669 } 4670 } 4671 fieldNum := int32(wire >> 3) 4672 wireType := int(wire & 0x7) 4673 if wireType == 4 { 4674 return fmt.Errorf("proto: WriteBatch: wiretype end group for non-group") 4675 } 4676 if fieldNum <= 0 { 4677 return fmt.Errorf("proto: WriteBatch: illegal tag %d (wire type %d)", fieldNum, wire) 4678 } 4679 switch fieldNum { 4680 case 1: 4681 if wireType != 2 { 4682 return fmt.Errorf("proto: wrong wireType = %d for field Writes", wireType) 4683 } 4684 var msglen int 4685 for shift := uint(0); ; shift += 7 { 4686 if shift >= 64 { 4687 return ErrIntOverflowGrpc 4688 } 4689 if iNdEx >= l { 4690 return io.ErrUnexpectedEOF 4691 } 4692 b := dAtA[iNdEx] 4693 iNdEx++ 4694 msglen |= int(b&0x7F) << shift 4695 if b < 0x80 { 4696 break 4697 } 4698 } 4699 if msglen < 0 { 4700 return ErrInvalidLengthGrpc 4701 } 4702 postIndex := iNdEx + msglen 4703 if postIndex < 0 { 4704 return ErrInvalidLengthGrpc 4705 } 4706 if postIndex > l { 4707 return io.ErrUnexpectedEOF 4708 } 4709 m.Writes = append(m.Writes, &IndexEntry{}) 4710 if err := m.Writes[len(m.Writes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 4711 return err 4712 } 4713 iNdEx = postIndex 4714 case 2: 4715 if wireType != 2 { 4716 return fmt.Errorf("proto: wrong wireType = %d for field Deletes", wireType) 4717 } 4718 var msglen int 4719 for shift := uint(0); ; shift += 7 { 4720 if shift >= 64 { 4721 return ErrIntOverflowGrpc 4722 } 4723 if iNdEx >= l { 4724 return io.ErrUnexpectedEOF 4725 } 4726 b := dAtA[iNdEx] 4727 iNdEx++ 4728 msglen |= int(b&0x7F) << shift 4729 if b < 0x80 { 4730 break 4731 } 4732 } 4733 if msglen < 0 { 4734 return ErrInvalidLengthGrpc 4735 } 4736 postIndex := iNdEx + msglen 4737 if postIndex < 0 { 4738 return ErrInvalidLengthGrpc 4739 } 4740 if postIndex > l { 4741 return io.ErrUnexpectedEOF 4742 } 4743 m.Deletes = append(m.Deletes, &IndexEntry{}) 4744 if err := m.Deletes[len(m.Deletes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 4745 return err 4746 } 4747 iNdEx = postIndex 4748 default: 4749 iNdEx = preIndex 4750 skippy, err := skipGrpc(dAtA[iNdEx:]) 4751 if err != nil { 4752 return err 4753 } 4754 if skippy < 0 { 4755 return ErrInvalidLengthGrpc 4756 } 4757 if (iNdEx + skippy) < 0 { 4758 return ErrInvalidLengthGrpc 4759 } 4760 if (iNdEx + skippy) > l { 4761 return io.ErrUnexpectedEOF 4762 } 4763 iNdEx += skippy 4764 } 4765 } 4766 4767 if iNdEx > l { 4768 return io.ErrUnexpectedEOF 4769 } 4770 return nil 4771} 4772func (m *WriteIndexRequest) Unmarshal(dAtA []byte) error { 4773 l := len(dAtA) 4774 iNdEx := 0 4775 for iNdEx < l { 4776 preIndex := iNdEx 4777 var wire uint64 4778 for shift := uint(0); ; shift += 7 { 4779 if shift >= 64 { 4780 return ErrIntOverflowGrpc 4781 } 4782 if iNdEx >= l { 4783 return io.ErrUnexpectedEOF 4784 } 4785 b := dAtA[iNdEx] 4786 iNdEx++ 4787 wire |= uint64(b&0x7F) << shift 4788 if b < 0x80 { 4789 break 4790 } 4791 } 4792 fieldNum := int32(wire >> 3) 4793 wireType := int(wire & 0x7) 4794 if wireType == 4 { 4795 return fmt.Errorf("proto: WriteIndexRequest: wiretype end group for non-group") 4796 } 4797 if fieldNum <= 0 { 4798 return fmt.Errorf("proto: WriteIndexRequest: illegal tag %d (wire type %d)", fieldNum, wire) 4799 } 4800 switch fieldNum { 4801 case 1: 4802 if wireType != 2 { 4803 return fmt.Errorf("proto: wrong wireType = %d for field Writes", wireType) 4804 } 4805 var msglen int 4806 for shift := uint(0); ; shift += 7 { 4807 if shift >= 64 { 4808 return ErrIntOverflowGrpc 4809 } 4810 if iNdEx >= l { 4811 return io.ErrUnexpectedEOF 4812 } 4813 b := dAtA[iNdEx] 4814 iNdEx++ 4815 msglen |= int(b&0x7F) << shift 4816 if b < 0x80 { 4817 break 4818 } 4819 } 4820 if msglen < 0 { 4821 return ErrInvalidLengthGrpc 4822 } 4823 postIndex := iNdEx + msglen 4824 if postIndex < 0 { 4825 return ErrInvalidLengthGrpc 4826 } 4827 if postIndex > l { 4828 return io.ErrUnexpectedEOF 4829 } 4830 m.Writes = append(m.Writes, &IndexEntry{}) 4831 if err := m.Writes[len(m.Writes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 4832 return err 4833 } 4834 iNdEx = postIndex 4835 default: 4836 iNdEx = preIndex 4837 skippy, err := skipGrpc(dAtA[iNdEx:]) 4838 if err != nil { 4839 return err 4840 } 4841 if skippy < 0 { 4842 return ErrInvalidLengthGrpc 4843 } 4844 if (iNdEx + skippy) < 0 { 4845 return ErrInvalidLengthGrpc 4846 } 4847 if (iNdEx + skippy) > l { 4848 return io.ErrUnexpectedEOF 4849 } 4850 iNdEx += skippy 4851 } 4852 } 4853 4854 if iNdEx > l { 4855 return io.ErrUnexpectedEOF 4856 } 4857 return nil 4858} 4859func (m *DeleteIndexRequest) Unmarshal(dAtA []byte) error { 4860 l := len(dAtA) 4861 iNdEx := 0 4862 for iNdEx < l { 4863 preIndex := iNdEx 4864 var wire uint64 4865 for shift := uint(0); ; shift += 7 { 4866 if shift >= 64 { 4867 return ErrIntOverflowGrpc 4868 } 4869 if iNdEx >= l { 4870 return io.ErrUnexpectedEOF 4871 } 4872 b := dAtA[iNdEx] 4873 iNdEx++ 4874 wire |= uint64(b&0x7F) << shift 4875 if b < 0x80 { 4876 break 4877 } 4878 } 4879 fieldNum := int32(wire >> 3) 4880 wireType := int(wire & 0x7) 4881 if wireType == 4 { 4882 return fmt.Errorf("proto: DeleteIndexRequest: wiretype end group for non-group") 4883 } 4884 if fieldNum <= 0 { 4885 return fmt.Errorf("proto: DeleteIndexRequest: illegal tag %d (wire type %d)", fieldNum, wire) 4886 } 4887 switch fieldNum { 4888 case 1: 4889 if wireType != 2 { 4890 return fmt.Errorf("proto: wrong wireType = %d for field Deletes", wireType) 4891 } 4892 var msglen int 4893 for shift := uint(0); ; shift += 7 { 4894 if shift >= 64 { 4895 return ErrIntOverflowGrpc 4896 } 4897 if iNdEx >= l { 4898 return io.ErrUnexpectedEOF 4899 } 4900 b := dAtA[iNdEx] 4901 iNdEx++ 4902 msglen |= int(b&0x7F) << shift 4903 if b < 0x80 { 4904 break 4905 } 4906 } 4907 if msglen < 0 { 4908 return ErrInvalidLengthGrpc 4909 } 4910 postIndex := iNdEx + msglen 4911 if postIndex < 0 { 4912 return ErrInvalidLengthGrpc 4913 } 4914 if postIndex > l { 4915 return io.ErrUnexpectedEOF 4916 } 4917 m.Deletes = append(m.Deletes, &IndexEntry{}) 4918 if err := m.Deletes[len(m.Deletes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 4919 return err 4920 } 4921 iNdEx = postIndex 4922 default: 4923 iNdEx = preIndex 4924 skippy, err := skipGrpc(dAtA[iNdEx:]) 4925 if err != nil { 4926 return err 4927 } 4928 if skippy < 0 { 4929 return ErrInvalidLengthGrpc 4930 } 4931 if (iNdEx + skippy) < 0 { 4932 return ErrInvalidLengthGrpc 4933 } 4934 if (iNdEx + skippy) > l { 4935 return io.ErrUnexpectedEOF 4936 } 4937 iNdEx += skippy 4938 } 4939 } 4940 4941 if iNdEx > l { 4942 return io.ErrUnexpectedEOF 4943 } 4944 return nil 4945} 4946func (m *QueryIndexResponse) Unmarshal(dAtA []byte) error { 4947 l := len(dAtA) 4948 iNdEx := 0 4949 for iNdEx < l { 4950 preIndex := iNdEx 4951 var wire uint64 4952 for shift := uint(0); ; shift += 7 { 4953 if shift >= 64 { 4954 return ErrIntOverflowGrpc 4955 } 4956 if iNdEx >= l { 4957 return io.ErrUnexpectedEOF 4958 } 4959 b := dAtA[iNdEx] 4960 iNdEx++ 4961 wire |= uint64(b&0x7F) << shift 4962 if b < 0x80 { 4963 break 4964 } 4965 } 4966 fieldNum := int32(wire >> 3) 4967 wireType := int(wire & 0x7) 4968 if wireType == 4 { 4969 return fmt.Errorf("proto: QueryIndexResponse: wiretype end group for non-group") 4970 } 4971 if fieldNum <= 0 { 4972 return fmt.Errorf("proto: QueryIndexResponse: illegal tag %d (wire type %d)", fieldNum, wire) 4973 } 4974 switch fieldNum { 4975 case 1: 4976 if wireType != 2 { 4977 return fmt.Errorf("proto: wrong wireType = %d for field Rows", wireType) 4978 } 4979 var msglen int 4980 for shift := uint(0); ; shift += 7 { 4981 if shift >= 64 { 4982 return ErrIntOverflowGrpc 4983 } 4984 if iNdEx >= l { 4985 return io.ErrUnexpectedEOF 4986 } 4987 b := dAtA[iNdEx] 4988 iNdEx++ 4989 msglen |= int(b&0x7F) << shift 4990 if b < 0x80 { 4991 break 4992 } 4993 } 4994 if msglen < 0 { 4995 return ErrInvalidLengthGrpc 4996 } 4997 postIndex := iNdEx + msglen 4998 if postIndex < 0 { 4999 return ErrInvalidLengthGrpc 5000 } 5001 if postIndex > l { 5002 return io.ErrUnexpectedEOF 5003 } 5004 m.Rows = append(m.Rows, &Row{}) 5005 if err := m.Rows[len(m.Rows)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5006 return err 5007 } 5008 iNdEx = postIndex 5009 default: 5010 iNdEx = preIndex 5011 skippy, err := skipGrpc(dAtA[iNdEx:]) 5012 if err != nil { 5013 return err 5014 } 5015 if skippy < 0 { 5016 return ErrInvalidLengthGrpc 5017 } 5018 if (iNdEx + skippy) < 0 { 5019 return ErrInvalidLengthGrpc 5020 } 5021 if (iNdEx + skippy) > l { 5022 return io.ErrUnexpectedEOF 5023 } 5024 iNdEx += skippy 5025 } 5026 } 5027 5028 if iNdEx > l { 5029 return io.ErrUnexpectedEOF 5030 } 5031 return nil 5032} 5033func (m *Row) Unmarshal(dAtA []byte) error { 5034 l := len(dAtA) 5035 iNdEx := 0 5036 for iNdEx < l { 5037 preIndex := iNdEx 5038 var wire uint64 5039 for shift := uint(0); ; shift += 7 { 5040 if shift >= 64 { 5041 return ErrIntOverflowGrpc 5042 } 5043 if iNdEx >= l { 5044 return io.ErrUnexpectedEOF 5045 } 5046 b := dAtA[iNdEx] 5047 iNdEx++ 5048 wire |= uint64(b&0x7F) << shift 5049 if b < 0x80 { 5050 break 5051 } 5052 } 5053 fieldNum := int32(wire >> 3) 5054 wireType := int(wire & 0x7) 5055 if wireType == 4 { 5056 return fmt.Errorf("proto: Row: wiretype end group for non-group") 5057 } 5058 if fieldNum <= 0 { 5059 return fmt.Errorf("proto: Row: illegal tag %d (wire type %d)", fieldNum, wire) 5060 } 5061 switch fieldNum { 5062 case 1: 5063 if wireType != 2 { 5064 return fmt.Errorf("proto: wrong wireType = %d for field RangeValue", wireType) 5065 } 5066 var byteLen int 5067 for shift := uint(0); ; shift += 7 { 5068 if shift >= 64 { 5069 return ErrIntOverflowGrpc 5070 } 5071 if iNdEx >= l { 5072 return io.ErrUnexpectedEOF 5073 } 5074 b := dAtA[iNdEx] 5075 iNdEx++ 5076 byteLen |= int(b&0x7F) << shift 5077 if b < 0x80 { 5078 break 5079 } 5080 } 5081 if byteLen < 0 { 5082 return ErrInvalidLengthGrpc 5083 } 5084 postIndex := iNdEx + byteLen 5085 if postIndex < 0 { 5086 return ErrInvalidLengthGrpc 5087 } 5088 if postIndex > l { 5089 return io.ErrUnexpectedEOF 5090 } 5091 m.RangeValue = append(m.RangeValue[:0], dAtA[iNdEx:postIndex]...) 5092 if m.RangeValue == nil { 5093 m.RangeValue = []byte{} 5094 } 5095 iNdEx = postIndex 5096 case 2: 5097 if wireType != 2 { 5098 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 5099 } 5100 var byteLen int 5101 for shift := uint(0); ; shift += 7 { 5102 if shift >= 64 { 5103 return ErrIntOverflowGrpc 5104 } 5105 if iNdEx >= l { 5106 return io.ErrUnexpectedEOF 5107 } 5108 b := dAtA[iNdEx] 5109 iNdEx++ 5110 byteLen |= int(b&0x7F) << shift 5111 if b < 0x80 { 5112 break 5113 } 5114 } 5115 if byteLen < 0 { 5116 return ErrInvalidLengthGrpc 5117 } 5118 postIndex := iNdEx + byteLen 5119 if postIndex < 0 { 5120 return ErrInvalidLengthGrpc 5121 } 5122 if postIndex > l { 5123 return io.ErrUnexpectedEOF 5124 } 5125 m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) 5126 if m.Value == nil { 5127 m.Value = []byte{} 5128 } 5129 iNdEx = postIndex 5130 default: 5131 iNdEx = preIndex 5132 skippy, err := skipGrpc(dAtA[iNdEx:]) 5133 if err != nil { 5134 return err 5135 } 5136 if skippy < 0 { 5137 return ErrInvalidLengthGrpc 5138 } 5139 if (iNdEx + skippy) < 0 { 5140 return ErrInvalidLengthGrpc 5141 } 5142 if (iNdEx + skippy) > l { 5143 return io.ErrUnexpectedEOF 5144 } 5145 iNdEx += skippy 5146 } 5147 } 5148 5149 if iNdEx > l { 5150 return io.ErrUnexpectedEOF 5151 } 5152 return nil 5153} 5154func (m *IndexEntry) Unmarshal(dAtA []byte) error { 5155 l := len(dAtA) 5156 iNdEx := 0 5157 for iNdEx < l { 5158 preIndex := iNdEx 5159 var wire uint64 5160 for shift := uint(0); ; shift += 7 { 5161 if shift >= 64 { 5162 return ErrIntOverflowGrpc 5163 } 5164 if iNdEx >= l { 5165 return io.ErrUnexpectedEOF 5166 } 5167 b := dAtA[iNdEx] 5168 iNdEx++ 5169 wire |= uint64(b&0x7F) << shift 5170 if b < 0x80 { 5171 break 5172 } 5173 } 5174 fieldNum := int32(wire >> 3) 5175 wireType := int(wire & 0x7) 5176 if wireType == 4 { 5177 return fmt.Errorf("proto: IndexEntry: wiretype end group for non-group") 5178 } 5179 if fieldNum <= 0 { 5180 return fmt.Errorf("proto: IndexEntry: illegal tag %d (wire type %d)", fieldNum, wire) 5181 } 5182 switch fieldNum { 5183 case 1: 5184 if wireType != 2 { 5185 return fmt.Errorf("proto: wrong wireType = %d for field TableName", wireType) 5186 } 5187 var stringLen uint64 5188 for shift := uint(0); ; shift += 7 { 5189 if shift >= 64 { 5190 return ErrIntOverflowGrpc 5191 } 5192 if iNdEx >= l { 5193 return io.ErrUnexpectedEOF 5194 } 5195 b := dAtA[iNdEx] 5196 iNdEx++ 5197 stringLen |= uint64(b&0x7F) << shift 5198 if b < 0x80 { 5199 break 5200 } 5201 } 5202 intStringLen := int(stringLen) 5203 if intStringLen < 0 { 5204 return ErrInvalidLengthGrpc 5205 } 5206 postIndex := iNdEx + intStringLen 5207 if postIndex < 0 { 5208 return ErrInvalidLengthGrpc 5209 } 5210 if postIndex > l { 5211 return io.ErrUnexpectedEOF 5212 } 5213 m.TableName = string(dAtA[iNdEx:postIndex]) 5214 iNdEx = postIndex 5215 case 2: 5216 if wireType != 2 { 5217 return fmt.Errorf("proto: wrong wireType = %d for field HashValue", wireType) 5218 } 5219 var stringLen uint64 5220 for shift := uint(0); ; shift += 7 { 5221 if shift >= 64 { 5222 return ErrIntOverflowGrpc 5223 } 5224 if iNdEx >= l { 5225 return io.ErrUnexpectedEOF 5226 } 5227 b := dAtA[iNdEx] 5228 iNdEx++ 5229 stringLen |= uint64(b&0x7F) << shift 5230 if b < 0x80 { 5231 break 5232 } 5233 } 5234 intStringLen := int(stringLen) 5235 if intStringLen < 0 { 5236 return ErrInvalidLengthGrpc 5237 } 5238 postIndex := iNdEx + intStringLen 5239 if postIndex < 0 { 5240 return ErrInvalidLengthGrpc 5241 } 5242 if postIndex > l { 5243 return io.ErrUnexpectedEOF 5244 } 5245 m.HashValue = string(dAtA[iNdEx:postIndex]) 5246 iNdEx = postIndex 5247 case 3: 5248 if wireType != 2 { 5249 return fmt.Errorf("proto: wrong wireType = %d for field RangeValue", wireType) 5250 } 5251 var byteLen int 5252 for shift := uint(0); ; shift += 7 { 5253 if shift >= 64 { 5254 return ErrIntOverflowGrpc 5255 } 5256 if iNdEx >= l { 5257 return io.ErrUnexpectedEOF 5258 } 5259 b := dAtA[iNdEx] 5260 iNdEx++ 5261 byteLen |= int(b&0x7F) << shift 5262 if b < 0x80 { 5263 break 5264 } 5265 } 5266 if byteLen < 0 { 5267 return ErrInvalidLengthGrpc 5268 } 5269 postIndex := iNdEx + byteLen 5270 if postIndex < 0 { 5271 return ErrInvalidLengthGrpc 5272 } 5273 if postIndex > l { 5274 return io.ErrUnexpectedEOF 5275 } 5276 m.RangeValue = append(m.RangeValue[:0], dAtA[iNdEx:postIndex]...) 5277 if m.RangeValue == nil { 5278 m.RangeValue = []byte{} 5279 } 5280 iNdEx = postIndex 5281 case 4: 5282 if wireType != 2 { 5283 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 5284 } 5285 var byteLen int 5286 for shift := uint(0); ; shift += 7 { 5287 if shift >= 64 { 5288 return ErrIntOverflowGrpc 5289 } 5290 if iNdEx >= l { 5291 return io.ErrUnexpectedEOF 5292 } 5293 b := dAtA[iNdEx] 5294 iNdEx++ 5295 byteLen |= int(b&0x7F) << shift 5296 if b < 0x80 { 5297 break 5298 } 5299 } 5300 if byteLen < 0 { 5301 return ErrInvalidLengthGrpc 5302 } 5303 postIndex := iNdEx + byteLen 5304 if postIndex < 0 { 5305 return ErrInvalidLengthGrpc 5306 } 5307 if postIndex > l { 5308 return io.ErrUnexpectedEOF 5309 } 5310 m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) 5311 if m.Value == nil { 5312 m.Value = []byte{} 5313 } 5314 iNdEx = postIndex 5315 default: 5316 iNdEx = preIndex 5317 skippy, err := skipGrpc(dAtA[iNdEx:]) 5318 if err != nil { 5319 return err 5320 } 5321 if skippy < 0 { 5322 return ErrInvalidLengthGrpc 5323 } 5324 if (iNdEx + skippy) < 0 { 5325 return ErrInvalidLengthGrpc 5326 } 5327 if (iNdEx + skippy) > l { 5328 return io.ErrUnexpectedEOF 5329 } 5330 iNdEx += skippy 5331 } 5332 } 5333 5334 if iNdEx > l { 5335 return io.ErrUnexpectedEOF 5336 } 5337 return nil 5338} 5339func (m *QueryIndexRequest) Unmarshal(dAtA []byte) error { 5340 l := len(dAtA) 5341 iNdEx := 0 5342 for iNdEx < l { 5343 preIndex := iNdEx 5344 var wire uint64 5345 for shift := uint(0); ; shift += 7 { 5346 if shift >= 64 { 5347 return ErrIntOverflowGrpc 5348 } 5349 if iNdEx >= l { 5350 return io.ErrUnexpectedEOF 5351 } 5352 b := dAtA[iNdEx] 5353 iNdEx++ 5354 wire |= uint64(b&0x7F) << shift 5355 if b < 0x80 { 5356 break 5357 } 5358 } 5359 fieldNum := int32(wire >> 3) 5360 wireType := int(wire & 0x7) 5361 if wireType == 4 { 5362 return fmt.Errorf("proto: QueryIndexRequest: wiretype end group for non-group") 5363 } 5364 if fieldNum <= 0 { 5365 return fmt.Errorf("proto: QueryIndexRequest: illegal tag %d (wire type %d)", fieldNum, wire) 5366 } 5367 switch fieldNum { 5368 case 1: 5369 if wireType != 2 { 5370 return fmt.Errorf("proto: wrong wireType = %d for field TableName", wireType) 5371 } 5372 var stringLen uint64 5373 for shift := uint(0); ; shift += 7 { 5374 if shift >= 64 { 5375 return ErrIntOverflowGrpc 5376 } 5377 if iNdEx >= l { 5378 return io.ErrUnexpectedEOF 5379 } 5380 b := dAtA[iNdEx] 5381 iNdEx++ 5382 stringLen |= uint64(b&0x7F) << shift 5383 if b < 0x80 { 5384 break 5385 } 5386 } 5387 intStringLen := int(stringLen) 5388 if intStringLen < 0 { 5389 return ErrInvalidLengthGrpc 5390 } 5391 postIndex := iNdEx + intStringLen 5392 if postIndex < 0 { 5393 return ErrInvalidLengthGrpc 5394 } 5395 if postIndex > l { 5396 return io.ErrUnexpectedEOF 5397 } 5398 m.TableName = string(dAtA[iNdEx:postIndex]) 5399 iNdEx = postIndex 5400 case 2: 5401 if wireType != 2 { 5402 return fmt.Errorf("proto: wrong wireType = %d for field HashValue", wireType) 5403 } 5404 var stringLen uint64 5405 for shift := uint(0); ; shift += 7 { 5406 if shift >= 64 { 5407 return ErrIntOverflowGrpc 5408 } 5409 if iNdEx >= l { 5410 return io.ErrUnexpectedEOF 5411 } 5412 b := dAtA[iNdEx] 5413 iNdEx++ 5414 stringLen |= uint64(b&0x7F) << shift 5415 if b < 0x80 { 5416 break 5417 } 5418 } 5419 intStringLen := int(stringLen) 5420 if intStringLen < 0 { 5421 return ErrInvalidLengthGrpc 5422 } 5423 postIndex := iNdEx + intStringLen 5424 if postIndex < 0 { 5425 return ErrInvalidLengthGrpc 5426 } 5427 if postIndex > l { 5428 return io.ErrUnexpectedEOF 5429 } 5430 m.HashValue = string(dAtA[iNdEx:postIndex]) 5431 iNdEx = postIndex 5432 case 3: 5433 if wireType != 2 { 5434 return fmt.Errorf("proto: wrong wireType = %d for field RangeValuePrefix", wireType) 5435 } 5436 var byteLen int 5437 for shift := uint(0); ; shift += 7 { 5438 if shift >= 64 { 5439 return ErrIntOverflowGrpc 5440 } 5441 if iNdEx >= l { 5442 return io.ErrUnexpectedEOF 5443 } 5444 b := dAtA[iNdEx] 5445 iNdEx++ 5446 byteLen |= int(b&0x7F) << shift 5447 if b < 0x80 { 5448 break 5449 } 5450 } 5451 if byteLen < 0 { 5452 return ErrInvalidLengthGrpc 5453 } 5454 postIndex := iNdEx + byteLen 5455 if postIndex < 0 { 5456 return ErrInvalidLengthGrpc 5457 } 5458 if postIndex > l { 5459 return io.ErrUnexpectedEOF 5460 } 5461 m.RangeValuePrefix = append(m.RangeValuePrefix[:0], dAtA[iNdEx:postIndex]...) 5462 if m.RangeValuePrefix == nil { 5463 m.RangeValuePrefix = []byte{} 5464 } 5465 iNdEx = postIndex 5466 case 4: 5467 if wireType != 2 { 5468 return fmt.Errorf("proto: wrong wireType = %d for field RangeValueStart", wireType) 5469 } 5470 var byteLen int 5471 for shift := uint(0); ; shift += 7 { 5472 if shift >= 64 { 5473 return ErrIntOverflowGrpc 5474 } 5475 if iNdEx >= l { 5476 return io.ErrUnexpectedEOF 5477 } 5478 b := dAtA[iNdEx] 5479 iNdEx++ 5480 byteLen |= int(b&0x7F) << shift 5481 if b < 0x80 { 5482 break 5483 } 5484 } 5485 if byteLen < 0 { 5486 return ErrInvalidLengthGrpc 5487 } 5488 postIndex := iNdEx + byteLen 5489 if postIndex < 0 { 5490 return ErrInvalidLengthGrpc 5491 } 5492 if postIndex > l { 5493 return io.ErrUnexpectedEOF 5494 } 5495 m.RangeValueStart = append(m.RangeValueStart[:0], dAtA[iNdEx:postIndex]...) 5496 if m.RangeValueStart == nil { 5497 m.RangeValueStart = []byte{} 5498 } 5499 iNdEx = postIndex 5500 case 5: 5501 if wireType != 2 { 5502 return fmt.Errorf("proto: wrong wireType = %d for field ValueEqual", wireType) 5503 } 5504 var byteLen int 5505 for shift := uint(0); ; shift += 7 { 5506 if shift >= 64 { 5507 return ErrIntOverflowGrpc 5508 } 5509 if iNdEx >= l { 5510 return io.ErrUnexpectedEOF 5511 } 5512 b := dAtA[iNdEx] 5513 iNdEx++ 5514 byteLen |= int(b&0x7F) << shift 5515 if b < 0x80 { 5516 break 5517 } 5518 } 5519 if byteLen < 0 { 5520 return ErrInvalidLengthGrpc 5521 } 5522 postIndex := iNdEx + byteLen 5523 if postIndex < 0 { 5524 return ErrInvalidLengthGrpc 5525 } 5526 if postIndex > l { 5527 return io.ErrUnexpectedEOF 5528 } 5529 m.ValueEqual = append(m.ValueEqual[:0], dAtA[iNdEx:postIndex]...) 5530 if m.ValueEqual == nil { 5531 m.ValueEqual = []byte{} 5532 } 5533 iNdEx = postIndex 5534 case 6: 5535 if wireType != 0 { 5536 return fmt.Errorf("proto: wrong wireType = %d for field Immutable", wireType) 5537 } 5538 var v int 5539 for shift := uint(0); ; shift += 7 { 5540 if shift >= 64 { 5541 return ErrIntOverflowGrpc 5542 } 5543 if iNdEx >= l { 5544 return io.ErrUnexpectedEOF 5545 } 5546 b := dAtA[iNdEx] 5547 iNdEx++ 5548 v |= int(b&0x7F) << shift 5549 if b < 0x80 { 5550 break 5551 } 5552 } 5553 m.Immutable = bool(v != 0) 5554 default: 5555 iNdEx = preIndex 5556 skippy, err := skipGrpc(dAtA[iNdEx:]) 5557 if err != nil { 5558 return err 5559 } 5560 if skippy < 0 { 5561 return ErrInvalidLengthGrpc 5562 } 5563 if (iNdEx + skippy) < 0 { 5564 return ErrInvalidLengthGrpc 5565 } 5566 if (iNdEx + skippy) > l { 5567 return io.ErrUnexpectedEOF 5568 } 5569 iNdEx += skippy 5570 } 5571 } 5572 5573 if iNdEx > l { 5574 return io.ErrUnexpectedEOF 5575 } 5576 return nil 5577} 5578func (m *UpdateTableRequest) Unmarshal(dAtA []byte) error { 5579 l := len(dAtA) 5580 iNdEx := 0 5581 for iNdEx < l { 5582 preIndex := iNdEx 5583 var wire uint64 5584 for shift := uint(0); ; shift += 7 { 5585 if shift >= 64 { 5586 return ErrIntOverflowGrpc 5587 } 5588 if iNdEx >= l { 5589 return io.ErrUnexpectedEOF 5590 } 5591 b := dAtA[iNdEx] 5592 iNdEx++ 5593 wire |= uint64(b&0x7F) << shift 5594 if b < 0x80 { 5595 break 5596 } 5597 } 5598 fieldNum := int32(wire >> 3) 5599 wireType := int(wire & 0x7) 5600 if wireType == 4 { 5601 return fmt.Errorf("proto: UpdateTableRequest: wiretype end group for non-group") 5602 } 5603 if fieldNum <= 0 { 5604 return fmt.Errorf("proto: UpdateTableRequest: illegal tag %d (wire type %d)", fieldNum, wire) 5605 } 5606 switch fieldNum { 5607 case 1: 5608 if wireType != 2 { 5609 return fmt.Errorf("proto: wrong wireType = %d for field Current", wireType) 5610 } 5611 var msglen int 5612 for shift := uint(0); ; shift += 7 { 5613 if shift >= 64 { 5614 return ErrIntOverflowGrpc 5615 } 5616 if iNdEx >= l { 5617 return io.ErrUnexpectedEOF 5618 } 5619 b := dAtA[iNdEx] 5620 iNdEx++ 5621 msglen |= int(b&0x7F) << shift 5622 if b < 0x80 { 5623 break 5624 } 5625 } 5626 if msglen < 0 { 5627 return ErrInvalidLengthGrpc 5628 } 5629 postIndex := iNdEx + msglen 5630 if postIndex < 0 { 5631 return ErrInvalidLengthGrpc 5632 } 5633 if postIndex > l { 5634 return io.ErrUnexpectedEOF 5635 } 5636 if m.Current == nil { 5637 m.Current = &TableDesc{} 5638 } 5639 if err := m.Current.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5640 return err 5641 } 5642 iNdEx = postIndex 5643 case 2: 5644 if wireType != 2 { 5645 return fmt.Errorf("proto: wrong wireType = %d for field Expected", wireType) 5646 } 5647 var msglen int 5648 for shift := uint(0); ; shift += 7 { 5649 if shift >= 64 { 5650 return ErrIntOverflowGrpc 5651 } 5652 if iNdEx >= l { 5653 return io.ErrUnexpectedEOF 5654 } 5655 b := dAtA[iNdEx] 5656 iNdEx++ 5657 msglen |= int(b&0x7F) << shift 5658 if b < 0x80 { 5659 break 5660 } 5661 } 5662 if msglen < 0 { 5663 return ErrInvalidLengthGrpc 5664 } 5665 postIndex := iNdEx + msglen 5666 if postIndex < 0 { 5667 return ErrInvalidLengthGrpc 5668 } 5669 if postIndex > l { 5670 return io.ErrUnexpectedEOF 5671 } 5672 if m.Expected == nil { 5673 m.Expected = &TableDesc{} 5674 } 5675 if err := m.Expected.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5676 return err 5677 } 5678 iNdEx = postIndex 5679 default: 5680 iNdEx = preIndex 5681 skippy, err := skipGrpc(dAtA[iNdEx:]) 5682 if err != nil { 5683 return err 5684 } 5685 if skippy < 0 { 5686 return ErrInvalidLengthGrpc 5687 } 5688 if (iNdEx + skippy) < 0 { 5689 return ErrInvalidLengthGrpc 5690 } 5691 if (iNdEx + skippy) > l { 5692 return io.ErrUnexpectedEOF 5693 } 5694 iNdEx += skippy 5695 } 5696 } 5697 5698 if iNdEx > l { 5699 return io.ErrUnexpectedEOF 5700 } 5701 return nil 5702} 5703func (m *DescribeTableResponse) Unmarshal(dAtA []byte) error { 5704 l := len(dAtA) 5705 iNdEx := 0 5706 for iNdEx < l { 5707 preIndex := iNdEx 5708 var wire uint64 5709 for shift := uint(0); ; shift += 7 { 5710 if shift >= 64 { 5711 return ErrIntOverflowGrpc 5712 } 5713 if iNdEx >= l { 5714 return io.ErrUnexpectedEOF 5715 } 5716 b := dAtA[iNdEx] 5717 iNdEx++ 5718 wire |= uint64(b&0x7F) << shift 5719 if b < 0x80 { 5720 break 5721 } 5722 } 5723 fieldNum := int32(wire >> 3) 5724 wireType := int(wire & 0x7) 5725 if wireType == 4 { 5726 return fmt.Errorf("proto: DescribeTableResponse: wiretype end group for non-group") 5727 } 5728 if fieldNum <= 0 { 5729 return fmt.Errorf("proto: DescribeTableResponse: illegal tag %d (wire type %d)", fieldNum, wire) 5730 } 5731 switch fieldNum { 5732 case 1: 5733 if wireType != 2 { 5734 return fmt.Errorf("proto: wrong wireType = %d for field Desc", wireType) 5735 } 5736 var msglen int 5737 for shift := uint(0); ; shift += 7 { 5738 if shift >= 64 { 5739 return ErrIntOverflowGrpc 5740 } 5741 if iNdEx >= l { 5742 return io.ErrUnexpectedEOF 5743 } 5744 b := dAtA[iNdEx] 5745 iNdEx++ 5746 msglen |= int(b&0x7F) << shift 5747 if b < 0x80 { 5748 break 5749 } 5750 } 5751 if msglen < 0 { 5752 return ErrInvalidLengthGrpc 5753 } 5754 postIndex := iNdEx + msglen 5755 if postIndex < 0 { 5756 return ErrInvalidLengthGrpc 5757 } 5758 if postIndex > l { 5759 return io.ErrUnexpectedEOF 5760 } 5761 if m.Desc == nil { 5762 m.Desc = &TableDesc{} 5763 } 5764 if err := m.Desc.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5765 return err 5766 } 5767 iNdEx = postIndex 5768 case 2: 5769 if wireType != 0 { 5770 return fmt.Errorf("proto: wrong wireType = %d for field IsActive", wireType) 5771 } 5772 var v int 5773 for shift := uint(0); ; shift += 7 { 5774 if shift >= 64 { 5775 return ErrIntOverflowGrpc 5776 } 5777 if iNdEx >= l { 5778 return io.ErrUnexpectedEOF 5779 } 5780 b := dAtA[iNdEx] 5781 iNdEx++ 5782 v |= int(b&0x7F) << shift 5783 if b < 0x80 { 5784 break 5785 } 5786 } 5787 m.IsActive = bool(v != 0) 5788 default: 5789 iNdEx = preIndex 5790 skippy, err := skipGrpc(dAtA[iNdEx:]) 5791 if err != nil { 5792 return err 5793 } 5794 if skippy < 0 { 5795 return ErrInvalidLengthGrpc 5796 } 5797 if (iNdEx + skippy) < 0 { 5798 return ErrInvalidLengthGrpc 5799 } 5800 if (iNdEx + skippy) > l { 5801 return io.ErrUnexpectedEOF 5802 } 5803 iNdEx += skippy 5804 } 5805 } 5806 5807 if iNdEx > l { 5808 return io.ErrUnexpectedEOF 5809 } 5810 return nil 5811} 5812func (m *CreateTableRequest) Unmarshal(dAtA []byte) error { 5813 l := len(dAtA) 5814 iNdEx := 0 5815 for iNdEx < l { 5816 preIndex := iNdEx 5817 var wire uint64 5818 for shift := uint(0); ; shift += 7 { 5819 if shift >= 64 { 5820 return ErrIntOverflowGrpc 5821 } 5822 if iNdEx >= l { 5823 return io.ErrUnexpectedEOF 5824 } 5825 b := dAtA[iNdEx] 5826 iNdEx++ 5827 wire |= uint64(b&0x7F) << shift 5828 if b < 0x80 { 5829 break 5830 } 5831 } 5832 fieldNum := int32(wire >> 3) 5833 wireType := int(wire & 0x7) 5834 if wireType == 4 { 5835 return fmt.Errorf("proto: CreateTableRequest: wiretype end group for non-group") 5836 } 5837 if fieldNum <= 0 { 5838 return fmt.Errorf("proto: CreateTableRequest: illegal tag %d (wire type %d)", fieldNum, wire) 5839 } 5840 switch fieldNum { 5841 case 1: 5842 if wireType != 2 { 5843 return fmt.Errorf("proto: wrong wireType = %d for field Desc", wireType) 5844 } 5845 var msglen int 5846 for shift := uint(0); ; shift += 7 { 5847 if shift >= 64 { 5848 return ErrIntOverflowGrpc 5849 } 5850 if iNdEx >= l { 5851 return io.ErrUnexpectedEOF 5852 } 5853 b := dAtA[iNdEx] 5854 iNdEx++ 5855 msglen |= int(b&0x7F) << shift 5856 if b < 0x80 { 5857 break 5858 } 5859 } 5860 if msglen < 0 { 5861 return ErrInvalidLengthGrpc 5862 } 5863 postIndex := iNdEx + msglen 5864 if postIndex < 0 { 5865 return ErrInvalidLengthGrpc 5866 } 5867 if postIndex > l { 5868 return io.ErrUnexpectedEOF 5869 } 5870 if m.Desc == nil { 5871 m.Desc = &TableDesc{} 5872 } 5873 if err := m.Desc.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5874 return err 5875 } 5876 iNdEx = postIndex 5877 default: 5878 iNdEx = preIndex 5879 skippy, err := skipGrpc(dAtA[iNdEx:]) 5880 if err != nil { 5881 return err 5882 } 5883 if skippy < 0 { 5884 return ErrInvalidLengthGrpc 5885 } 5886 if (iNdEx + skippy) < 0 { 5887 return ErrInvalidLengthGrpc 5888 } 5889 if (iNdEx + skippy) > l { 5890 return io.ErrUnexpectedEOF 5891 } 5892 iNdEx += skippy 5893 } 5894 } 5895 5896 if iNdEx > l { 5897 return io.ErrUnexpectedEOF 5898 } 5899 return nil 5900} 5901func (m *TableDesc) Unmarshal(dAtA []byte) error { 5902 l := len(dAtA) 5903 iNdEx := 0 5904 for iNdEx < l { 5905 preIndex := iNdEx 5906 var wire uint64 5907 for shift := uint(0); ; shift += 7 { 5908 if shift >= 64 { 5909 return ErrIntOverflowGrpc 5910 } 5911 if iNdEx >= l { 5912 return io.ErrUnexpectedEOF 5913 } 5914 b := dAtA[iNdEx] 5915 iNdEx++ 5916 wire |= uint64(b&0x7F) << shift 5917 if b < 0x80 { 5918 break 5919 } 5920 } 5921 fieldNum := int32(wire >> 3) 5922 wireType := int(wire & 0x7) 5923 if wireType == 4 { 5924 return fmt.Errorf("proto: TableDesc: wiretype end group for non-group") 5925 } 5926 if fieldNum <= 0 { 5927 return fmt.Errorf("proto: TableDesc: illegal tag %d (wire type %d)", fieldNum, wire) 5928 } 5929 switch fieldNum { 5930 case 1: 5931 if wireType != 2 { 5932 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) 5933 } 5934 var stringLen uint64 5935 for shift := uint(0); ; shift += 7 { 5936 if shift >= 64 { 5937 return ErrIntOverflowGrpc 5938 } 5939 if iNdEx >= l { 5940 return io.ErrUnexpectedEOF 5941 } 5942 b := dAtA[iNdEx] 5943 iNdEx++ 5944 stringLen |= uint64(b&0x7F) << shift 5945 if b < 0x80 { 5946 break 5947 } 5948 } 5949 intStringLen := int(stringLen) 5950 if intStringLen < 0 { 5951 return ErrInvalidLengthGrpc 5952 } 5953 postIndex := iNdEx + intStringLen 5954 if postIndex < 0 { 5955 return ErrInvalidLengthGrpc 5956 } 5957 if postIndex > l { 5958 return io.ErrUnexpectedEOF 5959 } 5960 m.Name = string(dAtA[iNdEx:postIndex]) 5961 iNdEx = postIndex 5962 case 2: 5963 if wireType != 0 { 5964 return fmt.Errorf("proto: wrong wireType = %d for field UseOnDemandIOMode", wireType) 5965 } 5966 var v int 5967 for shift := uint(0); ; shift += 7 { 5968 if shift >= 64 { 5969 return ErrIntOverflowGrpc 5970 } 5971 if iNdEx >= l { 5972 return io.ErrUnexpectedEOF 5973 } 5974 b := dAtA[iNdEx] 5975 iNdEx++ 5976 v |= int(b&0x7F) << shift 5977 if b < 0x80 { 5978 break 5979 } 5980 } 5981 m.UseOnDemandIOMode = bool(v != 0) 5982 case 3: 5983 if wireType != 0 { 5984 return fmt.Errorf("proto: wrong wireType = %d for field ProvisionedRead", wireType) 5985 } 5986 m.ProvisionedRead = 0 5987 for shift := uint(0); ; shift += 7 { 5988 if shift >= 64 { 5989 return ErrIntOverflowGrpc 5990 } 5991 if iNdEx >= l { 5992 return io.ErrUnexpectedEOF 5993 } 5994 b := dAtA[iNdEx] 5995 iNdEx++ 5996 m.ProvisionedRead |= int64(b&0x7F) << shift 5997 if b < 0x80 { 5998 break 5999 } 6000 } 6001 case 4: 6002 if wireType != 0 { 6003 return fmt.Errorf("proto: wrong wireType = %d for field ProvisionedWrite", wireType) 6004 } 6005 m.ProvisionedWrite = 0 6006 for shift := uint(0); ; shift += 7 { 6007 if shift >= 64 { 6008 return ErrIntOverflowGrpc 6009 } 6010 if iNdEx >= l { 6011 return io.ErrUnexpectedEOF 6012 } 6013 b := dAtA[iNdEx] 6014 iNdEx++ 6015 m.ProvisionedWrite |= int64(b&0x7F) << shift 6016 if b < 0x80 { 6017 break 6018 } 6019 } 6020 case 5: 6021 if wireType != 2 { 6022 return fmt.Errorf("proto: wrong wireType = %d for field Tags", wireType) 6023 } 6024 var msglen int 6025 for shift := uint(0); ; shift += 7 { 6026 if shift >= 64 { 6027 return ErrIntOverflowGrpc 6028 } 6029 if iNdEx >= l { 6030 return io.ErrUnexpectedEOF 6031 } 6032 b := dAtA[iNdEx] 6033 iNdEx++ 6034 msglen |= int(b&0x7F) << shift 6035 if b < 0x80 { 6036 break 6037 } 6038 } 6039 if msglen < 0 { 6040 return ErrInvalidLengthGrpc 6041 } 6042 postIndex := iNdEx + msglen 6043 if postIndex < 0 { 6044 return ErrInvalidLengthGrpc 6045 } 6046 if postIndex > l { 6047 return io.ErrUnexpectedEOF 6048 } 6049 if m.Tags == nil { 6050 m.Tags = make(map[string]string) 6051 } 6052 var mapkey string 6053 var mapvalue string 6054 for iNdEx < postIndex { 6055 entryPreIndex := iNdEx 6056 var wire uint64 6057 for shift := uint(0); ; shift += 7 { 6058 if shift >= 64 { 6059 return ErrIntOverflowGrpc 6060 } 6061 if iNdEx >= l { 6062 return io.ErrUnexpectedEOF 6063 } 6064 b := dAtA[iNdEx] 6065 iNdEx++ 6066 wire |= uint64(b&0x7F) << shift 6067 if b < 0x80 { 6068 break 6069 } 6070 } 6071 fieldNum := int32(wire >> 3) 6072 if fieldNum == 1 { 6073 var stringLenmapkey uint64 6074 for shift := uint(0); ; shift += 7 { 6075 if shift >= 64 { 6076 return ErrIntOverflowGrpc 6077 } 6078 if iNdEx >= l { 6079 return io.ErrUnexpectedEOF 6080 } 6081 b := dAtA[iNdEx] 6082 iNdEx++ 6083 stringLenmapkey |= uint64(b&0x7F) << shift 6084 if b < 0x80 { 6085 break 6086 } 6087 } 6088 intStringLenmapkey := int(stringLenmapkey) 6089 if intStringLenmapkey < 0 { 6090 return ErrInvalidLengthGrpc 6091 } 6092 postStringIndexmapkey := iNdEx + intStringLenmapkey 6093 if postStringIndexmapkey < 0 { 6094 return ErrInvalidLengthGrpc 6095 } 6096 if postStringIndexmapkey > l { 6097 return io.ErrUnexpectedEOF 6098 } 6099 mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) 6100 iNdEx = postStringIndexmapkey 6101 } else if fieldNum == 2 { 6102 var stringLenmapvalue uint64 6103 for shift := uint(0); ; shift += 7 { 6104 if shift >= 64 { 6105 return ErrIntOverflowGrpc 6106 } 6107 if iNdEx >= l { 6108 return io.ErrUnexpectedEOF 6109 } 6110 b := dAtA[iNdEx] 6111 iNdEx++ 6112 stringLenmapvalue |= uint64(b&0x7F) << shift 6113 if b < 0x80 { 6114 break 6115 } 6116 } 6117 intStringLenmapvalue := int(stringLenmapvalue) 6118 if intStringLenmapvalue < 0 { 6119 return ErrInvalidLengthGrpc 6120 } 6121 postStringIndexmapvalue := iNdEx + intStringLenmapvalue 6122 if postStringIndexmapvalue < 0 { 6123 return ErrInvalidLengthGrpc 6124 } 6125 if postStringIndexmapvalue > l { 6126 return io.ErrUnexpectedEOF 6127 } 6128 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) 6129 iNdEx = postStringIndexmapvalue 6130 } else { 6131 iNdEx = entryPreIndex 6132 skippy, err := skipGrpc(dAtA[iNdEx:]) 6133 if err != nil { 6134 return err 6135 } 6136 if skippy < 0 { 6137 return ErrInvalidLengthGrpc 6138 } 6139 if (iNdEx + skippy) > postIndex { 6140 return io.ErrUnexpectedEOF 6141 } 6142 iNdEx += skippy 6143 } 6144 } 6145 m.Tags[mapkey] = mapvalue 6146 iNdEx = postIndex 6147 default: 6148 iNdEx = preIndex 6149 skippy, err := skipGrpc(dAtA[iNdEx:]) 6150 if err != nil { 6151 return err 6152 } 6153 if skippy < 0 { 6154 return ErrInvalidLengthGrpc 6155 } 6156 if (iNdEx + skippy) < 0 { 6157 return ErrInvalidLengthGrpc 6158 } 6159 if (iNdEx + skippy) > l { 6160 return io.ErrUnexpectedEOF 6161 } 6162 iNdEx += skippy 6163 } 6164 } 6165 6166 if iNdEx > l { 6167 return io.ErrUnexpectedEOF 6168 } 6169 return nil 6170} 6171func (m *ListTablesResponse) Unmarshal(dAtA []byte) error { 6172 l := len(dAtA) 6173 iNdEx := 0 6174 for iNdEx < l { 6175 preIndex := iNdEx 6176 var wire uint64 6177 for shift := uint(0); ; shift += 7 { 6178 if shift >= 64 { 6179 return ErrIntOverflowGrpc 6180 } 6181 if iNdEx >= l { 6182 return io.ErrUnexpectedEOF 6183 } 6184 b := dAtA[iNdEx] 6185 iNdEx++ 6186 wire |= uint64(b&0x7F) << shift 6187 if b < 0x80 { 6188 break 6189 } 6190 } 6191 fieldNum := int32(wire >> 3) 6192 wireType := int(wire & 0x7) 6193 if wireType == 4 { 6194 return fmt.Errorf("proto: ListTablesResponse: wiretype end group for non-group") 6195 } 6196 if fieldNum <= 0 { 6197 return fmt.Errorf("proto: ListTablesResponse: illegal tag %d (wire type %d)", fieldNum, wire) 6198 } 6199 switch fieldNum { 6200 case 1: 6201 if wireType != 2 { 6202 return fmt.Errorf("proto: wrong wireType = %d for field TableNames", wireType) 6203 } 6204 var stringLen uint64 6205 for shift := uint(0); ; shift += 7 { 6206 if shift >= 64 { 6207 return ErrIntOverflowGrpc 6208 } 6209 if iNdEx >= l { 6210 return io.ErrUnexpectedEOF 6211 } 6212 b := dAtA[iNdEx] 6213 iNdEx++ 6214 stringLen |= uint64(b&0x7F) << shift 6215 if b < 0x80 { 6216 break 6217 } 6218 } 6219 intStringLen := int(stringLen) 6220 if intStringLen < 0 { 6221 return ErrInvalidLengthGrpc 6222 } 6223 postIndex := iNdEx + intStringLen 6224 if postIndex < 0 { 6225 return ErrInvalidLengthGrpc 6226 } 6227 if postIndex > l { 6228 return io.ErrUnexpectedEOF 6229 } 6230 m.TableNames = append(m.TableNames, string(dAtA[iNdEx:postIndex])) 6231 iNdEx = postIndex 6232 default: 6233 iNdEx = preIndex 6234 skippy, err := skipGrpc(dAtA[iNdEx:]) 6235 if err != nil { 6236 return err 6237 } 6238 if skippy < 0 { 6239 return ErrInvalidLengthGrpc 6240 } 6241 if (iNdEx + skippy) < 0 { 6242 return ErrInvalidLengthGrpc 6243 } 6244 if (iNdEx + skippy) > l { 6245 return io.ErrUnexpectedEOF 6246 } 6247 iNdEx += skippy 6248 } 6249 } 6250 6251 if iNdEx > l { 6252 return io.ErrUnexpectedEOF 6253 } 6254 return nil 6255} 6256func (m *Labels) Unmarshal(dAtA []byte) error { 6257 l := len(dAtA) 6258 iNdEx := 0 6259 for iNdEx < l { 6260 preIndex := iNdEx 6261 var wire uint64 6262 for shift := uint(0); ; shift += 7 { 6263 if shift >= 64 { 6264 return ErrIntOverflowGrpc 6265 } 6266 if iNdEx >= l { 6267 return io.ErrUnexpectedEOF 6268 } 6269 b := dAtA[iNdEx] 6270 iNdEx++ 6271 wire |= uint64(b&0x7F) << shift 6272 if b < 0x80 { 6273 break 6274 } 6275 } 6276 fieldNum := int32(wire >> 3) 6277 wireType := int(wire & 0x7) 6278 if wireType == 4 { 6279 return fmt.Errorf("proto: Labels: wiretype end group for non-group") 6280 } 6281 if fieldNum <= 0 { 6282 return fmt.Errorf("proto: Labels: illegal tag %d (wire type %d)", fieldNum, wire) 6283 } 6284 switch fieldNum { 6285 case 1: 6286 if wireType != 2 { 6287 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) 6288 } 6289 var stringLen uint64 6290 for shift := uint(0); ; shift += 7 { 6291 if shift >= 64 { 6292 return ErrIntOverflowGrpc 6293 } 6294 if iNdEx >= l { 6295 return io.ErrUnexpectedEOF 6296 } 6297 b := dAtA[iNdEx] 6298 iNdEx++ 6299 stringLen |= uint64(b&0x7F) << shift 6300 if b < 0x80 { 6301 break 6302 } 6303 } 6304 intStringLen := int(stringLen) 6305 if intStringLen < 0 { 6306 return ErrInvalidLengthGrpc 6307 } 6308 postIndex := iNdEx + intStringLen 6309 if postIndex < 0 { 6310 return ErrInvalidLengthGrpc 6311 } 6312 if postIndex > l { 6313 return io.ErrUnexpectedEOF 6314 } 6315 m.Name = string(dAtA[iNdEx:postIndex]) 6316 iNdEx = postIndex 6317 case 2: 6318 if wireType != 2 { 6319 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 6320 } 6321 var stringLen uint64 6322 for shift := uint(0); ; shift += 7 { 6323 if shift >= 64 { 6324 return ErrIntOverflowGrpc 6325 } 6326 if iNdEx >= l { 6327 return io.ErrUnexpectedEOF 6328 } 6329 b := dAtA[iNdEx] 6330 iNdEx++ 6331 stringLen |= uint64(b&0x7F) << shift 6332 if b < 0x80 { 6333 break 6334 } 6335 } 6336 intStringLen := int(stringLen) 6337 if intStringLen < 0 { 6338 return ErrInvalidLengthGrpc 6339 } 6340 postIndex := iNdEx + intStringLen 6341 if postIndex < 0 { 6342 return ErrInvalidLengthGrpc 6343 } 6344 if postIndex > l { 6345 return io.ErrUnexpectedEOF 6346 } 6347 m.Value = string(dAtA[iNdEx:postIndex]) 6348 iNdEx = postIndex 6349 default: 6350 iNdEx = preIndex 6351 skippy, err := skipGrpc(dAtA[iNdEx:]) 6352 if err != nil { 6353 return err 6354 } 6355 if skippy < 0 { 6356 return ErrInvalidLengthGrpc 6357 } 6358 if (iNdEx + skippy) < 0 { 6359 return ErrInvalidLengthGrpc 6360 } 6361 if (iNdEx + skippy) > l { 6362 return io.ErrUnexpectedEOF 6363 } 6364 iNdEx += skippy 6365 } 6366 } 6367 6368 if iNdEx > l { 6369 return io.ErrUnexpectedEOF 6370 } 6371 return nil 6372} 6373func skipGrpc(dAtA []byte) (n int, err error) { 6374 l := len(dAtA) 6375 iNdEx := 0 6376 for iNdEx < l { 6377 var wire uint64 6378 for shift := uint(0); ; shift += 7 { 6379 if shift >= 64 { 6380 return 0, ErrIntOverflowGrpc 6381 } 6382 if iNdEx >= l { 6383 return 0, io.ErrUnexpectedEOF 6384 } 6385 b := dAtA[iNdEx] 6386 iNdEx++ 6387 wire |= (uint64(b) & 0x7F) << shift 6388 if b < 0x80 { 6389 break 6390 } 6391 } 6392 wireType := int(wire & 0x7) 6393 switch wireType { 6394 case 0: 6395 for shift := uint(0); ; shift += 7 { 6396 if shift >= 64 { 6397 return 0, ErrIntOverflowGrpc 6398 } 6399 if iNdEx >= l { 6400 return 0, io.ErrUnexpectedEOF 6401 } 6402 iNdEx++ 6403 if dAtA[iNdEx-1] < 0x80 { 6404 break 6405 } 6406 } 6407 return iNdEx, nil 6408 case 1: 6409 iNdEx += 8 6410 return iNdEx, nil 6411 case 2: 6412 var length int 6413 for shift := uint(0); ; shift += 7 { 6414 if shift >= 64 { 6415 return 0, ErrIntOverflowGrpc 6416 } 6417 if iNdEx >= l { 6418 return 0, io.ErrUnexpectedEOF 6419 } 6420 b := dAtA[iNdEx] 6421 iNdEx++ 6422 length |= (int(b) & 0x7F) << shift 6423 if b < 0x80 { 6424 break 6425 } 6426 } 6427 if length < 0 { 6428 return 0, ErrInvalidLengthGrpc 6429 } 6430 iNdEx += length 6431 if iNdEx < 0 { 6432 return 0, ErrInvalidLengthGrpc 6433 } 6434 return iNdEx, nil 6435 case 3: 6436 for { 6437 var innerWire uint64 6438 var start int = iNdEx 6439 for shift := uint(0); ; shift += 7 { 6440 if shift >= 64 { 6441 return 0, ErrIntOverflowGrpc 6442 } 6443 if iNdEx >= l { 6444 return 0, io.ErrUnexpectedEOF 6445 } 6446 b := dAtA[iNdEx] 6447 iNdEx++ 6448 innerWire |= (uint64(b) & 0x7F) << shift 6449 if b < 0x80 { 6450 break 6451 } 6452 } 6453 innerWireType := int(innerWire & 0x7) 6454 if innerWireType == 4 { 6455 break 6456 } 6457 next, err := skipGrpc(dAtA[start:]) 6458 if err != nil { 6459 return 0, err 6460 } 6461 iNdEx = start + next 6462 if iNdEx < 0 { 6463 return 0, ErrInvalidLengthGrpc 6464 } 6465 } 6466 return iNdEx, nil 6467 case 4: 6468 return iNdEx, nil 6469 case 5: 6470 iNdEx += 4 6471 return iNdEx, nil 6472 default: 6473 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 6474 } 6475 } 6476 panic("unreachable") 6477} 6478 6479var ( 6480 ErrInvalidLengthGrpc = fmt.Errorf("proto: negative length found during unmarshaling") 6481 ErrIntOverflowGrpc = fmt.Errorf("proto: integer overflow") 6482) 6483