github.com/team-ide/go-dialect@v1.9.20/vitess/query/query_vtproto.pb.go (about) 1 // Code generated by protoc-gen-go-vtproto. DO NOT EDIT. 2 // protoc-gen-go-vtproto version: v0.2.0 3 // source: query.proto 4 5 package query 6 7 import ( 8 binary "encoding/binary" 9 fmt "fmt" 10 protoimpl "google.golang.org/protobuf/runtime/protoimpl" 11 io "io" 12 math "math" 13 bits "math/bits" 14 sync "sync" 15 topodata "github.com/team-ide/go-dialect/vitess/topodata" 16 vtrpc "github.com/team-ide/go-dialect/vitess/vtrpc" 17 ) 18 19 const ( 20 // Verify that this generated code is sufficiently up-to-date. 21 _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) 22 // Verify that runtime/protoimpl is sufficiently up-to-date. 23 _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) 24 ) 25 26 func (m *Target) MarshalVT() (dAtA []byte, err error) { 27 if m == nil { 28 return nil, nil 29 } 30 size := m.SizeVT() 31 dAtA = make([]byte, size) 32 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 33 if err != nil { 34 return nil, err 35 } 36 return dAtA[:n], nil 37 } 38 39 func (m *Target) MarshalToVT(dAtA []byte) (int, error) { 40 size := m.SizeVT() 41 return m.MarshalToSizedBufferVT(dAtA[:size]) 42 } 43 44 func (m *Target) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 45 if m == nil { 46 return 0, nil 47 } 48 i := len(dAtA) 49 _ = i 50 var l int 51 _ = l 52 if m.unknownFields != nil { 53 i -= len(m.unknownFields) 54 copy(dAtA[i:], m.unknownFields) 55 } 56 if len(m.Cell) > 0 { 57 i -= len(m.Cell) 58 copy(dAtA[i:], m.Cell) 59 i = encodeVarint(dAtA, i, uint64(len(m.Cell))) 60 i-- 61 dAtA[i] = 0x22 62 } 63 if m.TabletType != 0 { 64 i = encodeVarint(dAtA, i, uint64(m.TabletType)) 65 i-- 66 dAtA[i] = 0x18 67 } 68 if len(m.Shard) > 0 { 69 i -= len(m.Shard) 70 copy(dAtA[i:], m.Shard) 71 i = encodeVarint(dAtA, i, uint64(len(m.Shard))) 72 i-- 73 dAtA[i] = 0x12 74 } 75 if len(m.Keyspace) > 0 { 76 i -= len(m.Keyspace) 77 copy(dAtA[i:], m.Keyspace) 78 i = encodeVarint(dAtA, i, uint64(len(m.Keyspace))) 79 i-- 80 dAtA[i] = 0xa 81 } 82 return len(dAtA) - i, nil 83 } 84 85 func (m *VTGateCallerID) MarshalVT() (dAtA []byte, err error) { 86 if m == nil { 87 return nil, nil 88 } 89 size := m.SizeVT() 90 dAtA = make([]byte, size) 91 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 92 if err != nil { 93 return nil, err 94 } 95 return dAtA[:n], nil 96 } 97 98 func (m *VTGateCallerID) MarshalToVT(dAtA []byte) (int, error) { 99 size := m.SizeVT() 100 return m.MarshalToSizedBufferVT(dAtA[:size]) 101 } 102 103 func (m *VTGateCallerID) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 104 if m == nil { 105 return 0, nil 106 } 107 i := len(dAtA) 108 _ = i 109 var l int 110 _ = l 111 if m.unknownFields != nil { 112 i -= len(m.unknownFields) 113 copy(dAtA[i:], m.unknownFields) 114 } 115 if len(m.Groups) > 0 { 116 for iNdEx := len(m.Groups) - 1; iNdEx >= 0; iNdEx-- { 117 i -= len(m.Groups[iNdEx]) 118 copy(dAtA[i:], m.Groups[iNdEx]) 119 i = encodeVarint(dAtA, i, uint64(len(m.Groups[iNdEx]))) 120 i-- 121 dAtA[i] = 0x12 122 } 123 } 124 if len(m.Username) > 0 { 125 i -= len(m.Username) 126 copy(dAtA[i:], m.Username) 127 i = encodeVarint(dAtA, i, uint64(len(m.Username))) 128 i-- 129 dAtA[i] = 0xa 130 } 131 return len(dAtA) - i, nil 132 } 133 134 func (m *EventToken) MarshalVT() (dAtA []byte, err error) { 135 if m == nil { 136 return nil, nil 137 } 138 size := m.SizeVT() 139 dAtA = make([]byte, size) 140 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 141 if err != nil { 142 return nil, err 143 } 144 return dAtA[:n], nil 145 } 146 147 func (m *EventToken) MarshalToVT(dAtA []byte) (int, error) { 148 size := m.SizeVT() 149 return m.MarshalToSizedBufferVT(dAtA[:size]) 150 } 151 152 func (m *EventToken) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 153 if m == nil { 154 return 0, nil 155 } 156 i := len(dAtA) 157 _ = i 158 var l int 159 _ = l 160 if m.unknownFields != nil { 161 i -= len(m.unknownFields) 162 copy(dAtA[i:], m.unknownFields) 163 } 164 if len(m.Position) > 0 { 165 i -= len(m.Position) 166 copy(dAtA[i:], m.Position) 167 i = encodeVarint(dAtA, i, uint64(len(m.Position))) 168 i-- 169 dAtA[i] = 0x1a 170 } 171 if len(m.Shard) > 0 { 172 i -= len(m.Shard) 173 copy(dAtA[i:], m.Shard) 174 i = encodeVarint(dAtA, i, uint64(len(m.Shard))) 175 i-- 176 dAtA[i] = 0x12 177 } 178 if m.Timestamp != 0 { 179 i = encodeVarint(dAtA, i, uint64(m.Timestamp)) 180 i-- 181 dAtA[i] = 0x8 182 } 183 return len(dAtA) - i, nil 184 } 185 186 func (m *Value) MarshalVT() (dAtA []byte, err error) { 187 if m == nil { 188 return nil, nil 189 } 190 size := m.SizeVT() 191 dAtA = make([]byte, size) 192 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 193 if err != nil { 194 return nil, err 195 } 196 return dAtA[:n], nil 197 } 198 199 func (m *Value) MarshalToVT(dAtA []byte) (int, error) { 200 size := m.SizeVT() 201 return m.MarshalToSizedBufferVT(dAtA[:size]) 202 } 203 204 func (m *Value) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 205 if m == nil { 206 return 0, nil 207 } 208 i := len(dAtA) 209 _ = i 210 var l int 211 _ = l 212 if m.unknownFields != nil { 213 i -= len(m.unknownFields) 214 copy(dAtA[i:], m.unknownFields) 215 } 216 if len(m.Value) > 0 { 217 i -= len(m.Value) 218 copy(dAtA[i:], m.Value) 219 i = encodeVarint(dAtA, i, uint64(len(m.Value))) 220 i-- 221 dAtA[i] = 0x12 222 } 223 if m.Type != 0 { 224 i = encodeVarint(dAtA, i, uint64(m.Type)) 225 i-- 226 dAtA[i] = 0x8 227 } 228 return len(dAtA) - i, nil 229 } 230 231 func (m *BindVariable) MarshalVT() (dAtA []byte, err error) { 232 if m == nil { 233 return nil, nil 234 } 235 size := m.SizeVT() 236 dAtA = make([]byte, size) 237 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 238 if err != nil { 239 return nil, err 240 } 241 return dAtA[:n], nil 242 } 243 244 func (m *BindVariable) MarshalToVT(dAtA []byte) (int, error) { 245 size := m.SizeVT() 246 return m.MarshalToSizedBufferVT(dAtA[:size]) 247 } 248 249 func (m *BindVariable) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 250 if m == nil { 251 return 0, nil 252 } 253 i := len(dAtA) 254 _ = i 255 var l int 256 _ = l 257 if m.unknownFields != nil { 258 i -= len(m.unknownFields) 259 copy(dAtA[i:], m.unknownFields) 260 } 261 if len(m.Values) > 0 { 262 for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- { 263 size, err := m.Values[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) 264 if err != nil { 265 return 0, err 266 } 267 i -= size 268 i = encodeVarint(dAtA, i, uint64(size)) 269 i-- 270 dAtA[i] = 0x1a 271 } 272 } 273 if len(m.Value) > 0 { 274 i -= len(m.Value) 275 copy(dAtA[i:], m.Value) 276 i = encodeVarint(dAtA, i, uint64(len(m.Value))) 277 i-- 278 dAtA[i] = 0x12 279 } 280 if m.Type != 0 { 281 i = encodeVarint(dAtA, i, uint64(m.Type)) 282 i-- 283 dAtA[i] = 0x8 284 } 285 return len(dAtA) - i, nil 286 } 287 288 func (m *BoundQuery) MarshalVT() (dAtA []byte, err error) { 289 if m == nil { 290 return nil, nil 291 } 292 size := m.SizeVT() 293 dAtA = make([]byte, size) 294 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 295 if err != nil { 296 return nil, err 297 } 298 return dAtA[:n], nil 299 } 300 301 func (m *BoundQuery) MarshalToVT(dAtA []byte) (int, error) { 302 size := m.SizeVT() 303 return m.MarshalToSizedBufferVT(dAtA[:size]) 304 } 305 306 func (m *BoundQuery) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 307 if m == nil { 308 return 0, nil 309 } 310 i := len(dAtA) 311 _ = i 312 var l int 313 _ = l 314 if m.unknownFields != nil { 315 i -= len(m.unknownFields) 316 copy(dAtA[i:], m.unknownFields) 317 } 318 if len(m.BindVariables) > 0 { 319 for k := range m.BindVariables { 320 v := m.BindVariables[k] 321 baseI := i 322 size, err := v.MarshalToSizedBufferVT(dAtA[:i]) 323 if err != nil { 324 return 0, err 325 } 326 i -= size 327 i = encodeVarint(dAtA, i, uint64(size)) 328 i-- 329 dAtA[i] = 0x12 330 i -= len(k) 331 copy(dAtA[i:], k) 332 i = encodeVarint(dAtA, i, uint64(len(k))) 333 i-- 334 dAtA[i] = 0xa 335 i = encodeVarint(dAtA, i, uint64(baseI-i)) 336 i-- 337 dAtA[i] = 0x12 338 } 339 } 340 if len(m.Sql) > 0 { 341 i -= len(m.Sql) 342 copy(dAtA[i:], m.Sql) 343 i = encodeVarint(dAtA, i, uint64(len(m.Sql))) 344 i-- 345 dAtA[i] = 0xa 346 } 347 return len(dAtA) - i, nil 348 } 349 350 func (m *ExecuteOptions) MarshalVT() (dAtA []byte, err error) { 351 if m == nil { 352 return nil, nil 353 } 354 size := m.SizeVT() 355 dAtA = make([]byte, size) 356 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 357 if err != nil { 358 return nil, err 359 } 360 return dAtA[:n], nil 361 } 362 363 func (m *ExecuteOptions) MarshalToVT(dAtA []byte) (int, error) { 364 size := m.SizeVT() 365 return m.MarshalToSizedBufferVT(dAtA[:size]) 366 } 367 368 func (m *ExecuteOptions) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 369 if m == nil { 370 return 0, nil 371 } 372 i := len(dAtA) 373 _ = i 374 var l int 375 _ = l 376 if m.unknownFields != nil { 377 i -= len(m.unknownFields) 378 copy(dAtA[i:], m.unknownFields) 379 } 380 if m.HasCreatedTempTables { 381 i-- 382 if m.HasCreatedTempTables { 383 dAtA[i] = 1 384 } else { 385 dAtA[i] = 0 386 } 387 i-- 388 dAtA[i] = 0x60 389 } 390 if m.PlannerVersion != 0 { 391 i = encodeVarint(dAtA, i, uint64(m.PlannerVersion)) 392 i-- 393 dAtA[i] = 0x58 394 } 395 if m.SkipQueryPlanCache { 396 i-- 397 if m.SkipQueryPlanCache { 398 dAtA[i] = 1 399 } else { 400 dAtA[i] = 0 401 } 402 i-- 403 dAtA[i] = 0x50 404 } 405 if m.TransactionIsolation != 0 { 406 i = encodeVarint(dAtA, i, uint64(m.TransactionIsolation)) 407 i-- 408 dAtA[i] = 0x48 409 } 410 if m.SqlSelectLimit != 0 { 411 i = encodeVarint(dAtA, i, uint64(m.SqlSelectLimit)) 412 i-- 413 dAtA[i] = 0x40 414 } 415 if m.Workload != 0 { 416 i = encodeVarint(dAtA, i, uint64(m.Workload)) 417 i-- 418 dAtA[i] = 0x30 419 } 420 if m.ClientFoundRows { 421 i-- 422 if m.ClientFoundRows { 423 dAtA[i] = 1 424 } else { 425 dAtA[i] = 0 426 } 427 i-- 428 dAtA[i] = 0x28 429 } 430 if m.IncludedFields != 0 { 431 i = encodeVarint(dAtA, i, uint64(m.IncludedFields)) 432 i-- 433 dAtA[i] = 0x20 434 } 435 return len(dAtA) - i, nil 436 } 437 438 func (m *Field) MarshalVT() (dAtA []byte, err error) { 439 if m == nil { 440 return nil, nil 441 } 442 size := m.SizeVT() 443 dAtA = make([]byte, size) 444 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 445 if err != nil { 446 return nil, err 447 } 448 return dAtA[:n], nil 449 } 450 451 func (m *Field) MarshalToVT(dAtA []byte) (int, error) { 452 size := m.SizeVT() 453 return m.MarshalToSizedBufferVT(dAtA[:size]) 454 } 455 456 func (m *Field) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 457 if m == nil { 458 return 0, nil 459 } 460 i := len(dAtA) 461 _ = i 462 var l int 463 _ = l 464 if m.unknownFields != nil { 465 i -= len(m.unknownFields) 466 copy(dAtA[i:], m.unknownFields) 467 } 468 if len(m.ColumnType) > 0 { 469 i -= len(m.ColumnType) 470 copy(dAtA[i:], m.ColumnType) 471 i = encodeVarint(dAtA, i, uint64(len(m.ColumnType))) 472 i-- 473 dAtA[i] = 0x5a 474 } 475 if m.Flags != 0 { 476 i = encodeVarint(dAtA, i, uint64(m.Flags)) 477 i-- 478 dAtA[i] = 0x50 479 } 480 if m.Decimals != 0 { 481 i = encodeVarint(dAtA, i, uint64(m.Decimals)) 482 i-- 483 dAtA[i] = 0x48 484 } 485 if m.Charset != 0 { 486 i = encodeVarint(dAtA, i, uint64(m.Charset)) 487 i-- 488 dAtA[i] = 0x40 489 } 490 if m.ColumnLength != 0 { 491 i = encodeVarint(dAtA, i, uint64(m.ColumnLength)) 492 i-- 493 dAtA[i] = 0x38 494 } 495 if len(m.OrgName) > 0 { 496 i -= len(m.OrgName) 497 copy(dAtA[i:], m.OrgName) 498 i = encodeVarint(dAtA, i, uint64(len(m.OrgName))) 499 i-- 500 dAtA[i] = 0x32 501 } 502 if len(m.Database) > 0 { 503 i -= len(m.Database) 504 copy(dAtA[i:], m.Database) 505 i = encodeVarint(dAtA, i, uint64(len(m.Database))) 506 i-- 507 dAtA[i] = 0x2a 508 } 509 if len(m.OrgTable) > 0 { 510 i -= len(m.OrgTable) 511 copy(dAtA[i:], m.OrgTable) 512 i = encodeVarint(dAtA, i, uint64(len(m.OrgTable))) 513 i-- 514 dAtA[i] = 0x22 515 } 516 if len(m.Table) > 0 { 517 i -= len(m.Table) 518 copy(dAtA[i:], m.Table) 519 i = encodeVarint(dAtA, i, uint64(len(m.Table))) 520 i-- 521 dAtA[i] = 0x1a 522 } 523 if m.Type != 0 { 524 i = encodeVarint(dAtA, i, uint64(m.Type)) 525 i-- 526 dAtA[i] = 0x10 527 } 528 if len(m.Name) > 0 { 529 i -= len(m.Name) 530 copy(dAtA[i:], m.Name) 531 i = encodeVarint(dAtA, i, uint64(len(m.Name))) 532 i-- 533 dAtA[i] = 0xa 534 } 535 return len(dAtA) - i, nil 536 } 537 538 func (m *Row) MarshalVT() (dAtA []byte, err error) { 539 if m == nil { 540 return nil, nil 541 } 542 size := m.SizeVT() 543 dAtA = make([]byte, size) 544 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 545 if err != nil { 546 return nil, err 547 } 548 return dAtA[:n], nil 549 } 550 551 func (m *Row) MarshalToVT(dAtA []byte) (int, error) { 552 size := m.SizeVT() 553 return m.MarshalToSizedBufferVT(dAtA[:size]) 554 } 555 556 func (m *Row) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 557 if m == nil { 558 return 0, nil 559 } 560 i := len(dAtA) 561 _ = i 562 var l int 563 _ = l 564 if m.unknownFields != nil { 565 i -= len(m.unknownFields) 566 copy(dAtA[i:], m.unknownFields) 567 } 568 if len(m.Values) > 0 { 569 i -= len(m.Values) 570 copy(dAtA[i:], m.Values) 571 i = encodeVarint(dAtA, i, uint64(len(m.Values))) 572 i-- 573 dAtA[i] = 0x12 574 } 575 if len(m.Lengths) > 0 { 576 var pksize2 int 577 for _, num := range m.Lengths { 578 pksize2 += soz(uint64(num)) 579 } 580 i -= pksize2 581 j1 := i 582 for _, num := range m.Lengths { 583 x3 := (uint64(num) << 1) ^ uint64((num >> 63)) 584 for x3 >= 1<<7 { 585 dAtA[j1] = uint8(uint64(x3)&0x7f | 0x80) 586 j1++ 587 x3 >>= 7 588 } 589 dAtA[j1] = uint8(x3) 590 j1++ 591 } 592 i = encodeVarint(dAtA, i, uint64(pksize2)) 593 i-- 594 dAtA[i] = 0xa 595 } 596 return len(dAtA) - i, nil 597 } 598 599 func (m *QueryResult) MarshalVT() (dAtA []byte, err error) { 600 if m == nil { 601 return nil, nil 602 } 603 size := m.SizeVT() 604 dAtA = make([]byte, size) 605 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 606 if err != nil { 607 return nil, err 608 } 609 return dAtA[:n], nil 610 } 611 612 func (m *QueryResult) MarshalToVT(dAtA []byte) (int, error) { 613 size := m.SizeVT() 614 return m.MarshalToSizedBufferVT(dAtA[:size]) 615 } 616 617 func (m *QueryResult) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 618 if m == nil { 619 return 0, nil 620 } 621 i := len(dAtA) 622 _ = i 623 var l int 624 _ = l 625 if m.unknownFields != nil { 626 i -= len(m.unknownFields) 627 copy(dAtA[i:], m.unknownFields) 628 } 629 if len(m.Rows) > 0 { 630 for iNdEx := len(m.Rows) - 1; iNdEx >= 0; iNdEx-- { 631 size, err := m.Rows[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) 632 if err != nil { 633 return 0, err 634 } 635 i -= size 636 i = encodeVarint(dAtA, i, uint64(size)) 637 i-- 638 dAtA[i] = 0x22 639 } 640 } 641 if m.InsertId != 0 { 642 i = encodeVarint(dAtA, i, uint64(m.InsertId)) 643 i-- 644 dAtA[i] = 0x18 645 } 646 if m.RowsAffected != 0 { 647 i = encodeVarint(dAtA, i, uint64(m.RowsAffected)) 648 i-- 649 dAtA[i] = 0x10 650 } 651 if len(m.Fields) > 0 { 652 for iNdEx := len(m.Fields) - 1; iNdEx >= 0; iNdEx-- { 653 size, err := m.Fields[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) 654 if err != nil { 655 return 0, err 656 } 657 i -= size 658 i = encodeVarint(dAtA, i, uint64(size)) 659 i-- 660 dAtA[i] = 0xa 661 } 662 } 663 return len(dAtA) - i, nil 664 } 665 666 func (m *QueryWarning) MarshalVT() (dAtA []byte, err error) { 667 if m == nil { 668 return nil, nil 669 } 670 size := m.SizeVT() 671 dAtA = make([]byte, size) 672 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 673 if err != nil { 674 return nil, err 675 } 676 return dAtA[:n], nil 677 } 678 679 func (m *QueryWarning) MarshalToVT(dAtA []byte) (int, error) { 680 size := m.SizeVT() 681 return m.MarshalToSizedBufferVT(dAtA[:size]) 682 } 683 684 func (m *QueryWarning) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 685 if m == nil { 686 return 0, nil 687 } 688 i := len(dAtA) 689 _ = i 690 var l int 691 _ = l 692 if m.unknownFields != nil { 693 i -= len(m.unknownFields) 694 copy(dAtA[i:], m.unknownFields) 695 } 696 if len(m.Message) > 0 { 697 i -= len(m.Message) 698 copy(dAtA[i:], m.Message) 699 i = encodeVarint(dAtA, i, uint64(len(m.Message))) 700 i-- 701 dAtA[i] = 0x12 702 } 703 if m.Code != 0 { 704 i = encodeVarint(dAtA, i, uint64(m.Code)) 705 i-- 706 dAtA[i] = 0x8 707 } 708 return len(dAtA) - i, nil 709 } 710 711 func (m *StreamEvent_Statement) MarshalVT() (dAtA []byte, err error) { 712 if m == nil { 713 return nil, nil 714 } 715 size := m.SizeVT() 716 dAtA = make([]byte, size) 717 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 718 if err != nil { 719 return nil, err 720 } 721 return dAtA[:n], nil 722 } 723 724 func (m *StreamEvent_Statement) MarshalToVT(dAtA []byte) (int, error) { 725 size := m.SizeVT() 726 return m.MarshalToSizedBufferVT(dAtA[:size]) 727 } 728 729 func (m *StreamEvent_Statement) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 730 if m == nil { 731 return 0, nil 732 } 733 i := len(dAtA) 734 _ = i 735 var l int 736 _ = l 737 if m.unknownFields != nil { 738 i -= len(m.unknownFields) 739 copy(dAtA[i:], m.unknownFields) 740 } 741 if len(m.Sql) > 0 { 742 i -= len(m.Sql) 743 copy(dAtA[i:], m.Sql) 744 i = encodeVarint(dAtA, i, uint64(len(m.Sql))) 745 i-- 746 dAtA[i] = 0x2a 747 } 748 if len(m.PrimaryKeyValues) > 0 { 749 for iNdEx := len(m.PrimaryKeyValues) - 1; iNdEx >= 0; iNdEx-- { 750 size, err := m.PrimaryKeyValues[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) 751 if err != nil { 752 return 0, err 753 } 754 i -= size 755 i = encodeVarint(dAtA, i, uint64(size)) 756 i-- 757 dAtA[i] = 0x22 758 } 759 } 760 if len(m.PrimaryKeyFields) > 0 { 761 for iNdEx := len(m.PrimaryKeyFields) - 1; iNdEx >= 0; iNdEx-- { 762 size, err := m.PrimaryKeyFields[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) 763 if err != nil { 764 return 0, err 765 } 766 i -= size 767 i = encodeVarint(dAtA, i, uint64(size)) 768 i-- 769 dAtA[i] = 0x1a 770 } 771 } 772 if len(m.TableName) > 0 { 773 i -= len(m.TableName) 774 copy(dAtA[i:], m.TableName) 775 i = encodeVarint(dAtA, i, uint64(len(m.TableName))) 776 i-- 777 dAtA[i] = 0x12 778 } 779 if m.Category != 0 { 780 i = encodeVarint(dAtA, i, uint64(m.Category)) 781 i-- 782 dAtA[i] = 0x8 783 } 784 return len(dAtA) - i, nil 785 } 786 787 func (m *StreamEvent) MarshalVT() (dAtA []byte, err error) { 788 if m == nil { 789 return nil, nil 790 } 791 size := m.SizeVT() 792 dAtA = make([]byte, size) 793 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 794 if err != nil { 795 return nil, err 796 } 797 return dAtA[:n], nil 798 } 799 800 func (m *StreamEvent) MarshalToVT(dAtA []byte) (int, error) { 801 size := m.SizeVT() 802 return m.MarshalToSizedBufferVT(dAtA[:size]) 803 } 804 805 func (m *StreamEvent) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 806 if m == nil { 807 return 0, nil 808 } 809 i := len(dAtA) 810 _ = i 811 var l int 812 _ = l 813 if m.unknownFields != nil { 814 i -= len(m.unknownFields) 815 copy(dAtA[i:], m.unknownFields) 816 } 817 if m.EventToken != nil { 818 size, err := m.EventToken.MarshalToSizedBufferVT(dAtA[:i]) 819 if err != nil { 820 return 0, err 821 } 822 i -= size 823 i = encodeVarint(dAtA, i, uint64(size)) 824 i-- 825 dAtA[i] = 0x12 826 } 827 if len(m.Statements) > 0 { 828 for iNdEx := len(m.Statements) - 1; iNdEx >= 0; iNdEx-- { 829 size, err := m.Statements[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) 830 if err != nil { 831 return 0, err 832 } 833 i -= size 834 i = encodeVarint(dAtA, i, uint64(size)) 835 i-- 836 dAtA[i] = 0xa 837 } 838 } 839 return len(dAtA) - i, nil 840 } 841 842 func (m *ExecuteRequest) MarshalVT() (dAtA []byte, err error) { 843 if m == nil { 844 return nil, nil 845 } 846 size := m.SizeVT() 847 dAtA = make([]byte, size) 848 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 849 if err != nil { 850 return nil, err 851 } 852 return dAtA[:n], nil 853 } 854 855 func (m *ExecuteRequest) MarshalToVT(dAtA []byte) (int, error) { 856 size := m.SizeVT() 857 return m.MarshalToSizedBufferVT(dAtA[:size]) 858 } 859 860 func (m *ExecuteRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 861 if m == nil { 862 return 0, nil 863 } 864 i := len(dAtA) 865 _ = i 866 var l int 867 _ = l 868 if m.unknownFields != nil { 869 i -= len(m.unknownFields) 870 copy(dAtA[i:], m.unknownFields) 871 } 872 if m.ReservedId != 0 { 873 i = encodeVarint(dAtA, i, uint64(m.ReservedId)) 874 i-- 875 dAtA[i] = 0x38 876 } 877 if m.Options != nil { 878 size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i]) 879 if err != nil { 880 return 0, err 881 } 882 i -= size 883 i = encodeVarint(dAtA, i, uint64(size)) 884 i-- 885 dAtA[i] = 0x32 886 } 887 if m.TransactionId != 0 { 888 i = encodeVarint(dAtA, i, uint64(m.TransactionId)) 889 i-- 890 dAtA[i] = 0x28 891 } 892 if m.Query != nil { 893 size, err := m.Query.MarshalToSizedBufferVT(dAtA[:i]) 894 if err != nil { 895 return 0, err 896 } 897 i -= size 898 i = encodeVarint(dAtA, i, uint64(size)) 899 i-- 900 dAtA[i] = 0x22 901 } 902 if m.Target != nil { 903 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 904 if err != nil { 905 return 0, err 906 } 907 i -= size 908 i = encodeVarint(dAtA, i, uint64(size)) 909 i-- 910 dAtA[i] = 0x1a 911 } 912 if m.ImmediateCallerId != nil { 913 size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i]) 914 if err != nil { 915 return 0, err 916 } 917 i -= size 918 i = encodeVarint(dAtA, i, uint64(size)) 919 i-- 920 dAtA[i] = 0x12 921 } 922 if m.EffectiveCallerId != nil { 923 size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i]) 924 if err != nil { 925 return 0, err 926 } 927 i -= size 928 i = encodeVarint(dAtA, i, uint64(size)) 929 i-- 930 dAtA[i] = 0xa 931 } 932 return len(dAtA) - i, nil 933 } 934 935 func (m *ExecuteResponse) MarshalVT() (dAtA []byte, err error) { 936 if m == nil { 937 return nil, nil 938 } 939 size := m.SizeVT() 940 dAtA = make([]byte, size) 941 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 942 if err != nil { 943 return nil, err 944 } 945 return dAtA[:n], nil 946 } 947 948 func (m *ExecuteResponse) MarshalToVT(dAtA []byte) (int, error) { 949 size := m.SizeVT() 950 return m.MarshalToSizedBufferVT(dAtA[:size]) 951 } 952 953 func (m *ExecuteResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 954 if m == nil { 955 return 0, nil 956 } 957 i := len(dAtA) 958 _ = i 959 var l int 960 _ = l 961 if m.unknownFields != nil { 962 i -= len(m.unknownFields) 963 copy(dAtA[i:], m.unknownFields) 964 } 965 if m.Result != nil { 966 size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i]) 967 if err != nil { 968 return 0, err 969 } 970 i -= size 971 i = encodeVarint(dAtA, i, uint64(size)) 972 i-- 973 dAtA[i] = 0xa 974 } 975 return len(dAtA) - i, nil 976 } 977 978 func (m *ResultWithError) MarshalVT() (dAtA []byte, err error) { 979 if m == nil { 980 return nil, nil 981 } 982 size := m.SizeVT() 983 dAtA = make([]byte, size) 984 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 985 if err != nil { 986 return nil, err 987 } 988 return dAtA[:n], nil 989 } 990 991 func (m *ResultWithError) MarshalToVT(dAtA []byte) (int, error) { 992 size := m.SizeVT() 993 return m.MarshalToSizedBufferVT(dAtA[:size]) 994 } 995 996 func (m *ResultWithError) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 997 if m == nil { 998 return 0, nil 999 } 1000 i := len(dAtA) 1001 _ = i 1002 var l int 1003 _ = l 1004 if m.unknownFields != nil { 1005 i -= len(m.unknownFields) 1006 copy(dAtA[i:], m.unknownFields) 1007 } 1008 if m.Result != nil { 1009 size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i]) 1010 if err != nil { 1011 return 0, err 1012 } 1013 i -= size 1014 i = encodeVarint(dAtA, i, uint64(size)) 1015 i-- 1016 dAtA[i] = 0x12 1017 } 1018 if m.Error != nil { 1019 size, err := m.Error.MarshalToSizedBufferVT(dAtA[:i]) 1020 if err != nil { 1021 return 0, err 1022 } 1023 i -= size 1024 i = encodeVarint(dAtA, i, uint64(size)) 1025 i-- 1026 dAtA[i] = 0xa 1027 } 1028 return len(dAtA) - i, nil 1029 } 1030 1031 func (m *StreamExecuteRequest) MarshalVT() (dAtA []byte, err error) { 1032 if m == nil { 1033 return nil, nil 1034 } 1035 size := m.SizeVT() 1036 dAtA = make([]byte, size) 1037 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 1038 if err != nil { 1039 return nil, err 1040 } 1041 return dAtA[:n], nil 1042 } 1043 1044 func (m *StreamExecuteRequest) MarshalToVT(dAtA []byte) (int, error) { 1045 size := m.SizeVT() 1046 return m.MarshalToSizedBufferVT(dAtA[:size]) 1047 } 1048 1049 func (m *StreamExecuteRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 1050 if m == nil { 1051 return 0, nil 1052 } 1053 i := len(dAtA) 1054 _ = i 1055 var l int 1056 _ = l 1057 if m.unknownFields != nil { 1058 i -= len(m.unknownFields) 1059 copy(dAtA[i:], m.unknownFields) 1060 } 1061 if m.ReservedId != 0 { 1062 i = encodeVarint(dAtA, i, uint64(m.ReservedId)) 1063 i-- 1064 dAtA[i] = 0x38 1065 } 1066 if m.TransactionId != 0 { 1067 i = encodeVarint(dAtA, i, uint64(m.TransactionId)) 1068 i-- 1069 dAtA[i] = 0x30 1070 } 1071 if m.Options != nil { 1072 size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i]) 1073 if err != nil { 1074 return 0, err 1075 } 1076 i -= size 1077 i = encodeVarint(dAtA, i, uint64(size)) 1078 i-- 1079 dAtA[i] = 0x2a 1080 } 1081 if m.Query != nil { 1082 size, err := m.Query.MarshalToSizedBufferVT(dAtA[:i]) 1083 if err != nil { 1084 return 0, err 1085 } 1086 i -= size 1087 i = encodeVarint(dAtA, i, uint64(size)) 1088 i-- 1089 dAtA[i] = 0x22 1090 } 1091 if m.Target != nil { 1092 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 1093 if err != nil { 1094 return 0, err 1095 } 1096 i -= size 1097 i = encodeVarint(dAtA, i, uint64(size)) 1098 i-- 1099 dAtA[i] = 0x1a 1100 } 1101 if m.ImmediateCallerId != nil { 1102 size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i]) 1103 if err != nil { 1104 return 0, err 1105 } 1106 i -= size 1107 i = encodeVarint(dAtA, i, uint64(size)) 1108 i-- 1109 dAtA[i] = 0x12 1110 } 1111 if m.EffectiveCallerId != nil { 1112 size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i]) 1113 if err != nil { 1114 return 0, err 1115 } 1116 i -= size 1117 i = encodeVarint(dAtA, i, uint64(size)) 1118 i-- 1119 dAtA[i] = 0xa 1120 } 1121 return len(dAtA) - i, nil 1122 } 1123 1124 func (m *StreamExecuteResponse) MarshalVT() (dAtA []byte, err error) { 1125 if m == nil { 1126 return nil, nil 1127 } 1128 size := m.SizeVT() 1129 dAtA = make([]byte, size) 1130 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 1131 if err != nil { 1132 return nil, err 1133 } 1134 return dAtA[:n], nil 1135 } 1136 1137 func (m *StreamExecuteResponse) MarshalToVT(dAtA []byte) (int, error) { 1138 size := m.SizeVT() 1139 return m.MarshalToSizedBufferVT(dAtA[:size]) 1140 } 1141 1142 func (m *StreamExecuteResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 1143 if m == nil { 1144 return 0, nil 1145 } 1146 i := len(dAtA) 1147 _ = i 1148 var l int 1149 _ = l 1150 if m.unknownFields != nil { 1151 i -= len(m.unknownFields) 1152 copy(dAtA[i:], m.unknownFields) 1153 } 1154 if m.Result != nil { 1155 size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i]) 1156 if err != nil { 1157 return 0, err 1158 } 1159 i -= size 1160 i = encodeVarint(dAtA, i, uint64(size)) 1161 i-- 1162 dAtA[i] = 0xa 1163 } 1164 return len(dAtA) - i, nil 1165 } 1166 1167 func (m *BeginRequest) MarshalVT() (dAtA []byte, err error) { 1168 if m == nil { 1169 return nil, nil 1170 } 1171 size := m.SizeVT() 1172 dAtA = make([]byte, size) 1173 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 1174 if err != nil { 1175 return nil, err 1176 } 1177 return dAtA[:n], nil 1178 } 1179 1180 func (m *BeginRequest) MarshalToVT(dAtA []byte) (int, error) { 1181 size := m.SizeVT() 1182 return m.MarshalToSizedBufferVT(dAtA[:size]) 1183 } 1184 1185 func (m *BeginRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 1186 if m == nil { 1187 return 0, nil 1188 } 1189 i := len(dAtA) 1190 _ = i 1191 var l int 1192 _ = l 1193 if m.unknownFields != nil { 1194 i -= len(m.unknownFields) 1195 copy(dAtA[i:], m.unknownFields) 1196 } 1197 if m.Options != nil { 1198 size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i]) 1199 if err != nil { 1200 return 0, err 1201 } 1202 i -= size 1203 i = encodeVarint(dAtA, i, uint64(size)) 1204 i-- 1205 dAtA[i] = 0x22 1206 } 1207 if m.Target != nil { 1208 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 1209 if err != nil { 1210 return 0, err 1211 } 1212 i -= size 1213 i = encodeVarint(dAtA, i, uint64(size)) 1214 i-- 1215 dAtA[i] = 0x1a 1216 } 1217 if m.ImmediateCallerId != nil { 1218 size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i]) 1219 if err != nil { 1220 return 0, err 1221 } 1222 i -= size 1223 i = encodeVarint(dAtA, i, uint64(size)) 1224 i-- 1225 dAtA[i] = 0x12 1226 } 1227 if m.EffectiveCallerId != nil { 1228 size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i]) 1229 if err != nil { 1230 return 0, err 1231 } 1232 i -= size 1233 i = encodeVarint(dAtA, i, uint64(size)) 1234 i-- 1235 dAtA[i] = 0xa 1236 } 1237 return len(dAtA) - i, nil 1238 } 1239 1240 func (m *BeginResponse) MarshalVT() (dAtA []byte, err error) { 1241 if m == nil { 1242 return nil, nil 1243 } 1244 size := m.SizeVT() 1245 dAtA = make([]byte, size) 1246 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 1247 if err != nil { 1248 return nil, err 1249 } 1250 return dAtA[:n], nil 1251 } 1252 1253 func (m *BeginResponse) MarshalToVT(dAtA []byte) (int, error) { 1254 size := m.SizeVT() 1255 return m.MarshalToSizedBufferVT(dAtA[:size]) 1256 } 1257 1258 func (m *BeginResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 1259 if m == nil { 1260 return 0, nil 1261 } 1262 i := len(dAtA) 1263 _ = i 1264 var l int 1265 _ = l 1266 if m.unknownFields != nil { 1267 i -= len(m.unknownFields) 1268 copy(dAtA[i:], m.unknownFields) 1269 } 1270 if m.TabletAlias != nil { 1271 size, err := m.TabletAlias.MarshalToSizedBufferVT(dAtA[:i]) 1272 if err != nil { 1273 return 0, err 1274 } 1275 i -= size 1276 i = encodeVarint(dAtA, i, uint64(size)) 1277 i-- 1278 dAtA[i] = 0x12 1279 } 1280 if m.TransactionId != 0 { 1281 i = encodeVarint(dAtA, i, uint64(m.TransactionId)) 1282 i-- 1283 dAtA[i] = 0x8 1284 } 1285 return len(dAtA) - i, nil 1286 } 1287 1288 func (m *CommitRequest) MarshalVT() (dAtA []byte, err error) { 1289 if m == nil { 1290 return nil, nil 1291 } 1292 size := m.SizeVT() 1293 dAtA = make([]byte, size) 1294 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 1295 if err != nil { 1296 return nil, err 1297 } 1298 return dAtA[:n], nil 1299 } 1300 1301 func (m *CommitRequest) MarshalToVT(dAtA []byte) (int, error) { 1302 size := m.SizeVT() 1303 return m.MarshalToSizedBufferVT(dAtA[:size]) 1304 } 1305 1306 func (m *CommitRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 1307 if m == nil { 1308 return 0, nil 1309 } 1310 i := len(dAtA) 1311 _ = i 1312 var l int 1313 _ = l 1314 if m.unknownFields != nil { 1315 i -= len(m.unknownFields) 1316 copy(dAtA[i:], m.unknownFields) 1317 } 1318 if m.TransactionId != 0 { 1319 i = encodeVarint(dAtA, i, uint64(m.TransactionId)) 1320 i-- 1321 dAtA[i] = 0x20 1322 } 1323 if m.Target != nil { 1324 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 1325 if err != nil { 1326 return 0, err 1327 } 1328 i -= size 1329 i = encodeVarint(dAtA, i, uint64(size)) 1330 i-- 1331 dAtA[i] = 0x1a 1332 } 1333 if m.ImmediateCallerId != nil { 1334 size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i]) 1335 if err != nil { 1336 return 0, err 1337 } 1338 i -= size 1339 i = encodeVarint(dAtA, i, uint64(size)) 1340 i-- 1341 dAtA[i] = 0x12 1342 } 1343 if m.EffectiveCallerId != nil { 1344 size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i]) 1345 if err != nil { 1346 return 0, err 1347 } 1348 i -= size 1349 i = encodeVarint(dAtA, i, uint64(size)) 1350 i-- 1351 dAtA[i] = 0xa 1352 } 1353 return len(dAtA) - i, nil 1354 } 1355 1356 func (m *CommitResponse) MarshalVT() (dAtA []byte, err error) { 1357 if m == nil { 1358 return nil, nil 1359 } 1360 size := m.SizeVT() 1361 dAtA = make([]byte, size) 1362 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 1363 if err != nil { 1364 return nil, err 1365 } 1366 return dAtA[:n], nil 1367 } 1368 1369 func (m *CommitResponse) MarshalToVT(dAtA []byte) (int, error) { 1370 size := m.SizeVT() 1371 return m.MarshalToSizedBufferVT(dAtA[:size]) 1372 } 1373 1374 func (m *CommitResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 1375 if m == nil { 1376 return 0, nil 1377 } 1378 i := len(dAtA) 1379 _ = i 1380 var l int 1381 _ = l 1382 if m.unknownFields != nil { 1383 i -= len(m.unknownFields) 1384 copy(dAtA[i:], m.unknownFields) 1385 } 1386 if m.ReservedId != 0 { 1387 i = encodeVarint(dAtA, i, uint64(m.ReservedId)) 1388 i-- 1389 dAtA[i] = 0x8 1390 } 1391 return len(dAtA) - i, nil 1392 } 1393 1394 func (m *RollbackRequest) MarshalVT() (dAtA []byte, err error) { 1395 if m == nil { 1396 return nil, nil 1397 } 1398 size := m.SizeVT() 1399 dAtA = make([]byte, size) 1400 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 1401 if err != nil { 1402 return nil, err 1403 } 1404 return dAtA[:n], nil 1405 } 1406 1407 func (m *RollbackRequest) MarshalToVT(dAtA []byte) (int, error) { 1408 size := m.SizeVT() 1409 return m.MarshalToSizedBufferVT(dAtA[:size]) 1410 } 1411 1412 func (m *RollbackRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 1413 if m == nil { 1414 return 0, nil 1415 } 1416 i := len(dAtA) 1417 _ = i 1418 var l int 1419 _ = l 1420 if m.unknownFields != nil { 1421 i -= len(m.unknownFields) 1422 copy(dAtA[i:], m.unknownFields) 1423 } 1424 if m.TransactionId != 0 { 1425 i = encodeVarint(dAtA, i, uint64(m.TransactionId)) 1426 i-- 1427 dAtA[i] = 0x20 1428 } 1429 if m.Target != nil { 1430 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 1431 if err != nil { 1432 return 0, err 1433 } 1434 i -= size 1435 i = encodeVarint(dAtA, i, uint64(size)) 1436 i-- 1437 dAtA[i] = 0x1a 1438 } 1439 if m.ImmediateCallerId != nil { 1440 size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i]) 1441 if err != nil { 1442 return 0, err 1443 } 1444 i -= size 1445 i = encodeVarint(dAtA, i, uint64(size)) 1446 i-- 1447 dAtA[i] = 0x12 1448 } 1449 if m.EffectiveCallerId != nil { 1450 size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i]) 1451 if err != nil { 1452 return 0, err 1453 } 1454 i -= size 1455 i = encodeVarint(dAtA, i, uint64(size)) 1456 i-- 1457 dAtA[i] = 0xa 1458 } 1459 return len(dAtA) - i, nil 1460 } 1461 1462 func (m *RollbackResponse) MarshalVT() (dAtA []byte, err error) { 1463 if m == nil { 1464 return nil, nil 1465 } 1466 size := m.SizeVT() 1467 dAtA = make([]byte, size) 1468 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 1469 if err != nil { 1470 return nil, err 1471 } 1472 return dAtA[:n], nil 1473 } 1474 1475 func (m *RollbackResponse) MarshalToVT(dAtA []byte) (int, error) { 1476 size := m.SizeVT() 1477 return m.MarshalToSizedBufferVT(dAtA[:size]) 1478 } 1479 1480 func (m *RollbackResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 1481 if m == nil { 1482 return 0, nil 1483 } 1484 i := len(dAtA) 1485 _ = i 1486 var l int 1487 _ = l 1488 if m.unknownFields != nil { 1489 i -= len(m.unknownFields) 1490 copy(dAtA[i:], m.unknownFields) 1491 } 1492 if m.ReservedId != 0 { 1493 i = encodeVarint(dAtA, i, uint64(m.ReservedId)) 1494 i-- 1495 dAtA[i] = 0x8 1496 } 1497 return len(dAtA) - i, nil 1498 } 1499 1500 func (m *PrepareRequest) MarshalVT() (dAtA []byte, err error) { 1501 if m == nil { 1502 return nil, nil 1503 } 1504 size := m.SizeVT() 1505 dAtA = make([]byte, size) 1506 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 1507 if err != nil { 1508 return nil, err 1509 } 1510 return dAtA[:n], nil 1511 } 1512 1513 func (m *PrepareRequest) MarshalToVT(dAtA []byte) (int, error) { 1514 size := m.SizeVT() 1515 return m.MarshalToSizedBufferVT(dAtA[:size]) 1516 } 1517 1518 func (m *PrepareRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 1519 if m == nil { 1520 return 0, nil 1521 } 1522 i := len(dAtA) 1523 _ = i 1524 var l int 1525 _ = l 1526 if m.unknownFields != nil { 1527 i -= len(m.unknownFields) 1528 copy(dAtA[i:], m.unknownFields) 1529 } 1530 if len(m.Dtid) > 0 { 1531 i -= len(m.Dtid) 1532 copy(dAtA[i:], m.Dtid) 1533 i = encodeVarint(dAtA, i, uint64(len(m.Dtid))) 1534 i-- 1535 dAtA[i] = 0x2a 1536 } 1537 if m.TransactionId != 0 { 1538 i = encodeVarint(dAtA, i, uint64(m.TransactionId)) 1539 i-- 1540 dAtA[i] = 0x20 1541 } 1542 if m.Target != nil { 1543 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 1544 if err != nil { 1545 return 0, err 1546 } 1547 i -= size 1548 i = encodeVarint(dAtA, i, uint64(size)) 1549 i-- 1550 dAtA[i] = 0x1a 1551 } 1552 if m.ImmediateCallerId != nil { 1553 size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i]) 1554 if err != nil { 1555 return 0, err 1556 } 1557 i -= size 1558 i = encodeVarint(dAtA, i, uint64(size)) 1559 i-- 1560 dAtA[i] = 0x12 1561 } 1562 if m.EffectiveCallerId != nil { 1563 size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i]) 1564 if err != nil { 1565 return 0, err 1566 } 1567 i -= size 1568 i = encodeVarint(dAtA, i, uint64(size)) 1569 i-- 1570 dAtA[i] = 0xa 1571 } 1572 return len(dAtA) - i, nil 1573 } 1574 1575 func (m *PrepareResponse) MarshalVT() (dAtA []byte, err error) { 1576 if m == nil { 1577 return nil, nil 1578 } 1579 size := m.SizeVT() 1580 dAtA = make([]byte, size) 1581 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 1582 if err != nil { 1583 return nil, err 1584 } 1585 return dAtA[:n], nil 1586 } 1587 1588 func (m *PrepareResponse) MarshalToVT(dAtA []byte) (int, error) { 1589 size := m.SizeVT() 1590 return m.MarshalToSizedBufferVT(dAtA[:size]) 1591 } 1592 1593 func (m *PrepareResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 1594 if m == nil { 1595 return 0, nil 1596 } 1597 i := len(dAtA) 1598 _ = i 1599 var l int 1600 _ = l 1601 if m.unknownFields != nil { 1602 i -= len(m.unknownFields) 1603 copy(dAtA[i:], m.unknownFields) 1604 } 1605 return len(dAtA) - i, nil 1606 } 1607 1608 func (m *CommitPreparedRequest) MarshalVT() (dAtA []byte, err error) { 1609 if m == nil { 1610 return nil, nil 1611 } 1612 size := m.SizeVT() 1613 dAtA = make([]byte, size) 1614 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 1615 if err != nil { 1616 return nil, err 1617 } 1618 return dAtA[:n], nil 1619 } 1620 1621 func (m *CommitPreparedRequest) MarshalToVT(dAtA []byte) (int, error) { 1622 size := m.SizeVT() 1623 return m.MarshalToSizedBufferVT(dAtA[:size]) 1624 } 1625 1626 func (m *CommitPreparedRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 1627 if m == nil { 1628 return 0, nil 1629 } 1630 i := len(dAtA) 1631 _ = i 1632 var l int 1633 _ = l 1634 if m.unknownFields != nil { 1635 i -= len(m.unknownFields) 1636 copy(dAtA[i:], m.unknownFields) 1637 } 1638 if len(m.Dtid) > 0 { 1639 i -= len(m.Dtid) 1640 copy(dAtA[i:], m.Dtid) 1641 i = encodeVarint(dAtA, i, uint64(len(m.Dtid))) 1642 i-- 1643 dAtA[i] = 0x22 1644 } 1645 if m.Target != nil { 1646 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 1647 if err != nil { 1648 return 0, err 1649 } 1650 i -= size 1651 i = encodeVarint(dAtA, i, uint64(size)) 1652 i-- 1653 dAtA[i] = 0x1a 1654 } 1655 if m.ImmediateCallerId != nil { 1656 size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i]) 1657 if err != nil { 1658 return 0, err 1659 } 1660 i -= size 1661 i = encodeVarint(dAtA, i, uint64(size)) 1662 i-- 1663 dAtA[i] = 0x12 1664 } 1665 if m.EffectiveCallerId != nil { 1666 size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i]) 1667 if err != nil { 1668 return 0, err 1669 } 1670 i -= size 1671 i = encodeVarint(dAtA, i, uint64(size)) 1672 i-- 1673 dAtA[i] = 0xa 1674 } 1675 return len(dAtA) - i, nil 1676 } 1677 1678 func (m *CommitPreparedResponse) MarshalVT() (dAtA []byte, err error) { 1679 if m == nil { 1680 return nil, nil 1681 } 1682 size := m.SizeVT() 1683 dAtA = make([]byte, size) 1684 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 1685 if err != nil { 1686 return nil, err 1687 } 1688 return dAtA[:n], nil 1689 } 1690 1691 func (m *CommitPreparedResponse) MarshalToVT(dAtA []byte) (int, error) { 1692 size := m.SizeVT() 1693 return m.MarshalToSizedBufferVT(dAtA[:size]) 1694 } 1695 1696 func (m *CommitPreparedResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 1697 if m == nil { 1698 return 0, nil 1699 } 1700 i := len(dAtA) 1701 _ = i 1702 var l int 1703 _ = l 1704 if m.unknownFields != nil { 1705 i -= len(m.unknownFields) 1706 copy(dAtA[i:], m.unknownFields) 1707 } 1708 return len(dAtA) - i, nil 1709 } 1710 1711 func (m *RollbackPreparedRequest) MarshalVT() (dAtA []byte, err error) { 1712 if m == nil { 1713 return nil, nil 1714 } 1715 size := m.SizeVT() 1716 dAtA = make([]byte, size) 1717 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 1718 if err != nil { 1719 return nil, err 1720 } 1721 return dAtA[:n], nil 1722 } 1723 1724 func (m *RollbackPreparedRequest) MarshalToVT(dAtA []byte) (int, error) { 1725 size := m.SizeVT() 1726 return m.MarshalToSizedBufferVT(dAtA[:size]) 1727 } 1728 1729 func (m *RollbackPreparedRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 1730 if m == nil { 1731 return 0, nil 1732 } 1733 i := len(dAtA) 1734 _ = i 1735 var l int 1736 _ = l 1737 if m.unknownFields != nil { 1738 i -= len(m.unknownFields) 1739 copy(dAtA[i:], m.unknownFields) 1740 } 1741 if len(m.Dtid) > 0 { 1742 i -= len(m.Dtid) 1743 copy(dAtA[i:], m.Dtid) 1744 i = encodeVarint(dAtA, i, uint64(len(m.Dtid))) 1745 i-- 1746 dAtA[i] = 0x2a 1747 } 1748 if m.TransactionId != 0 { 1749 i = encodeVarint(dAtA, i, uint64(m.TransactionId)) 1750 i-- 1751 dAtA[i] = 0x20 1752 } 1753 if m.Target != nil { 1754 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 1755 if err != nil { 1756 return 0, err 1757 } 1758 i -= size 1759 i = encodeVarint(dAtA, i, uint64(size)) 1760 i-- 1761 dAtA[i] = 0x1a 1762 } 1763 if m.ImmediateCallerId != nil { 1764 size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i]) 1765 if err != nil { 1766 return 0, err 1767 } 1768 i -= size 1769 i = encodeVarint(dAtA, i, uint64(size)) 1770 i-- 1771 dAtA[i] = 0x12 1772 } 1773 if m.EffectiveCallerId != nil { 1774 size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i]) 1775 if err != nil { 1776 return 0, err 1777 } 1778 i -= size 1779 i = encodeVarint(dAtA, i, uint64(size)) 1780 i-- 1781 dAtA[i] = 0xa 1782 } 1783 return len(dAtA) - i, nil 1784 } 1785 1786 func (m *RollbackPreparedResponse) MarshalVT() (dAtA []byte, err error) { 1787 if m == nil { 1788 return nil, nil 1789 } 1790 size := m.SizeVT() 1791 dAtA = make([]byte, size) 1792 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 1793 if err != nil { 1794 return nil, err 1795 } 1796 return dAtA[:n], nil 1797 } 1798 1799 func (m *RollbackPreparedResponse) MarshalToVT(dAtA []byte) (int, error) { 1800 size := m.SizeVT() 1801 return m.MarshalToSizedBufferVT(dAtA[:size]) 1802 } 1803 1804 func (m *RollbackPreparedResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 1805 if m == nil { 1806 return 0, nil 1807 } 1808 i := len(dAtA) 1809 _ = i 1810 var l int 1811 _ = l 1812 if m.unknownFields != nil { 1813 i -= len(m.unknownFields) 1814 copy(dAtA[i:], m.unknownFields) 1815 } 1816 return len(dAtA) - i, nil 1817 } 1818 1819 func (m *CreateTransactionRequest) MarshalVT() (dAtA []byte, err error) { 1820 if m == nil { 1821 return nil, nil 1822 } 1823 size := m.SizeVT() 1824 dAtA = make([]byte, size) 1825 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 1826 if err != nil { 1827 return nil, err 1828 } 1829 return dAtA[:n], nil 1830 } 1831 1832 func (m *CreateTransactionRequest) MarshalToVT(dAtA []byte) (int, error) { 1833 size := m.SizeVT() 1834 return m.MarshalToSizedBufferVT(dAtA[:size]) 1835 } 1836 1837 func (m *CreateTransactionRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 1838 if m == nil { 1839 return 0, nil 1840 } 1841 i := len(dAtA) 1842 _ = i 1843 var l int 1844 _ = l 1845 if m.unknownFields != nil { 1846 i -= len(m.unknownFields) 1847 copy(dAtA[i:], m.unknownFields) 1848 } 1849 if len(m.Participants) > 0 { 1850 for iNdEx := len(m.Participants) - 1; iNdEx >= 0; iNdEx-- { 1851 size, err := m.Participants[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) 1852 if err != nil { 1853 return 0, err 1854 } 1855 i -= size 1856 i = encodeVarint(dAtA, i, uint64(size)) 1857 i-- 1858 dAtA[i] = 0x2a 1859 } 1860 } 1861 if len(m.Dtid) > 0 { 1862 i -= len(m.Dtid) 1863 copy(dAtA[i:], m.Dtid) 1864 i = encodeVarint(dAtA, i, uint64(len(m.Dtid))) 1865 i-- 1866 dAtA[i] = 0x22 1867 } 1868 if m.Target != nil { 1869 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 1870 if err != nil { 1871 return 0, err 1872 } 1873 i -= size 1874 i = encodeVarint(dAtA, i, uint64(size)) 1875 i-- 1876 dAtA[i] = 0x1a 1877 } 1878 if m.ImmediateCallerId != nil { 1879 size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i]) 1880 if err != nil { 1881 return 0, err 1882 } 1883 i -= size 1884 i = encodeVarint(dAtA, i, uint64(size)) 1885 i-- 1886 dAtA[i] = 0x12 1887 } 1888 if m.EffectiveCallerId != nil { 1889 size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i]) 1890 if err != nil { 1891 return 0, err 1892 } 1893 i -= size 1894 i = encodeVarint(dAtA, i, uint64(size)) 1895 i-- 1896 dAtA[i] = 0xa 1897 } 1898 return len(dAtA) - i, nil 1899 } 1900 1901 func (m *CreateTransactionResponse) MarshalVT() (dAtA []byte, err error) { 1902 if m == nil { 1903 return nil, nil 1904 } 1905 size := m.SizeVT() 1906 dAtA = make([]byte, size) 1907 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 1908 if err != nil { 1909 return nil, err 1910 } 1911 return dAtA[:n], nil 1912 } 1913 1914 func (m *CreateTransactionResponse) MarshalToVT(dAtA []byte) (int, error) { 1915 size := m.SizeVT() 1916 return m.MarshalToSizedBufferVT(dAtA[:size]) 1917 } 1918 1919 func (m *CreateTransactionResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 1920 if m == nil { 1921 return 0, nil 1922 } 1923 i := len(dAtA) 1924 _ = i 1925 var l int 1926 _ = l 1927 if m.unknownFields != nil { 1928 i -= len(m.unknownFields) 1929 copy(dAtA[i:], m.unknownFields) 1930 } 1931 return len(dAtA) - i, nil 1932 } 1933 1934 func (m *StartCommitRequest) MarshalVT() (dAtA []byte, err error) { 1935 if m == nil { 1936 return nil, nil 1937 } 1938 size := m.SizeVT() 1939 dAtA = make([]byte, size) 1940 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 1941 if err != nil { 1942 return nil, err 1943 } 1944 return dAtA[:n], nil 1945 } 1946 1947 func (m *StartCommitRequest) MarshalToVT(dAtA []byte) (int, error) { 1948 size := m.SizeVT() 1949 return m.MarshalToSizedBufferVT(dAtA[:size]) 1950 } 1951 1952 func (m *StartCommitRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 1953 if m == nil { 1954 return 0, nil 1955 } 1956 i := len(dAtA) 1957 _ = i 1958 var l int 1959 _ = l 1960 if m.unknownFields != nil { 1961 i -= len(m.unknownFields) 1962 copy(dAtA[i:], m.unknownFields) 1963 } 1964 if len(m.Dtid) > 0 { 1965 i -= len(m.Dtid) 1966 copy(dAtA[i:], m.Dtid) 1967 i = encodeVarint(dAtA, i, uint64(len(m.Dtid))) 1968 i-- 1969 dAtA[i] = 0x2a 1970 } 1971 if m.TransactionId != 0 { 1972 i = encodeVarint(dAtA, i, uint64(m.TransactionId)) 1973 i-- 1974 dAtA[i] = 0x20 1975 } 1976 if m.Target != nil { 1977 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 1978 if err != nil { 1979 return 0, err 1980 } 1981 i -= size 1982 i = encodeVarint(dAtA, i, uint64(size)) 1983 i-- 1984 dAtA[i] = 0x1a 1985 } 1986 if m.ImmediateCallerId != nil { 1987 size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i]) 1988 if err != nil { 1989 return 0, err 1990 } 1991 i -= size 1992 i = encodeVarint(dAtA, i, uint64(size)) 1993 i-- 1994 dAtA[i] = 0x12 1995 } 1996 if m.EffectiveCallerId != nil { 1997 size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i]) 1998 if err != nil { 1999 return 0, err 2000 } 2001 i -= size 2002 i = encodeVarint(dAtA, i, uint64(size)) 2003 i-- 2004 dAtA[i] = 0xa 2005 } 2006 return len(dAtA) - i, nil 2007 } 2008 2009 func (m *StartCommitResponse) MarshalVT() (dAtA []byte, err error) { 2010 if m == nil { 2011 return nil, nil 2012 } 2013 size := m.SizeVT() 2014 dAtA = make([]byte, size) 2015 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 2016 if err != nil { 2017 return nil, err 2018 } 2019 return dAtA[:n], nil 2020 } 2021 2022 func (m *StartCommitResponse) MarshalToVT(dAtA []byte) (int, error) { 2023 size := m.SizeVT() 2024 return m.MarshalToSizedBufferVT(dAtA[:size]) 2025 } 2026 2027 func (m *StartCommitResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 2028 if m == nil { 2029 return 0, nil 2030 } 2031 i := len(dAtA) 2032 _ = i 2033 var l int 2034 _ = l 2035 if m.unknownFields != nil { 2036 i -= len(m.unknownFields) 2037 copy(dAtA[i:], m.unknownFields) 2038 } 2039 return len(dAtA) - i, nil 2040 } 2041 2042 func (m *SetRollbackRequest) MarshalVT() (dAtA []byte, err error) { 2043 if m == nil { 2044 return nil, nil 2045 } 2046 size := m.SizeVT() 2047 dAtA = make([]byte, size) 2048 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 2049 if err != nil { 2050 return nil, err 2051 } 2052 return dAtA[:n], nil 2053 } 2054 2055 func (m *SetRollbackRequest) MarshalToVT(dAtA []byte) (int, error) { 2056 size := m.SizeVT() 2057 return m.MarshalToSizedBufferVT(dAtA[:size]) 2058 } 2059 2060 func (m *SetRollbackRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 2061 if m == nil { 2062 return 0, nil 2063 } 2064 i := len(dAtA) 2065 _ = i 2066 var l int 2067 _ = l 2068 if m.unknownFields != nil { 2069 i -= len(m.unknownFields) 2070 copy(dAtA[i:], m.unknownFields) 2071 } 2072 if len(m.Dtid) > 0 { 2073 i -= len(m.Dtid) 2074 copy(dAtA[i:], m.Dtid) 2075 i = encodeVarint(dAtA, i, uint64(len(m.Dtid))) 2076 i-- 2077 dAtA[i] = 0x2a 2078 } 2079 if m.TransactionId != 0 { 2080 i = encodeVarint(dAtA, i, uint64(m.TransactionId)) 2081 i-- 2082 dAtA[i] = 0x20 2083 } 2084 if m.Target != nil { 2085 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 2086 if err != nil { 2087 return 0, err 2088 } 2089 i -= size 2090 i = encodeVarint(dAtA, i, uint64(size)) 2091 i-- 2092 dAtA[i] = 0x1a 2093 } 2094 if m.ImmediateCallerId != nil { 2095 size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i]) 2096 if err != nil { 2097 return 0, err 2098 } 2099 i -= size 2100 i = encodeVarint(dAtA, i, uint64(size)) 2101 i-- 2102 dAtA[i] = 0x12 2103 } 2104 if m.EffectiveCallerId != nil { 2105 size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i]) 2106 if err != nil { 2107 return 0, err 2108 } 2109 i -= size 2110 i = encodeVarint(dAtA, i, uint64(size)) 2111 i-- 2112 dAtA[i] = 0xa 2113 } 2114 return len(dAtA) - i, nil 2115 } 2116 2117 func (m *SetRollbackResponse) MarshalVT() (dAtA []byte, err error) { 2118 if m == nil { 2119 return nil, nil 2120 } 2121 size := m.SizeVT() 2122 dAtA = make([]byte, size) 2123 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 2124 if err != nil { 2125 return nil, err 2126 } 2127 return dAtA[:n], nil 2128 } 2129 2130 func (m *SetRollbackResponse) MarshalToVT(dAtA []byte) (int, error) { 2131 size := m.SizeVT() 2132 return m.MarshalToSizedBufferVT(dAtA[:size]) 2133 } 2134 2135 func (m *SetRollbackResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 2136 if m == nil { 2137 return 0, nil 2138 } 2139 i := len(dAtA) 2140 _ = i 2141 var l int 2142 _ = l 2143 if m.unknownFields != nil { 2144 i -= len(m.unknownFields) 2145 copy(dAtA[i:], m.unknownFields) 2146 } 2147 return len(dAtA) - i, nil 2148 } 2149 2150 func (m *ConcludeTransactionRequest) MarshalVT() (dAtA []byte, err error) { 2151 if m == nil { 2152 return nil, nil 2153 } 2154 size := m.SizeVT() 2155 dAtA = make([]byte, size) 2156 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 2157 if err != nil { 2158 return nil, err 2159 } 2160 return dAtA[:n], nil 2161 } 2162 2163 func (m *ConcludeTransactionRequest) MarshalToVT(dAtA []byte) (int, error) { 2164 size := m.SizeVT() 2165 return m.MarshalToSizedBufferVT(dAtA[:size]) 2166 } 2167 2168 func (m *ConcludeTransactionRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 2169 if m == nil { 2170 return 0, nil 2171 } 2172 i := len(dAtA) 2173 _ = i 2174 var l int 2175 _ = l 2176 if m.unknownFields != nil { 2177 i -= len(m.unknownFields) 2178 copy(dAtA[i:], m.unknownFields) 2179 } 2180 if len(m.Dtid) > 0 { 2181 i -= len(m.Dtid) 2182 copy(dAtA[i:], m.Dtid) 2183 i = encodeVarint(dAtA, i, uint64(len(m.Dtid))) 2184 i-- 2185 dAtA[i] = 0x22 2186 } 2187 if m.Target != nil { 2188 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 2189 if err != nil { 2190 return 0, err 2191 } 2192 i -= size 2193 i = encodeVarint(dAtA, i, uint64(size)) 2194 i-- 2195 dAtA[i] = 0x1a 2196 } 2197 if m.ImmediateCallerId != nil { 2198 size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i]) 2199 if err != nil { 2200 return 0, err 2201 } 2202 i -= size 2203 i = encodeVarint(dAtA, i, uint64(size)) 2204 i-- 2205 dAtA[i] = 0x12 2206 } 2207 if m.EffectiveCallerId != nil { 2208 size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i]) 2209 if err != nil { 2210 return 0, err 2211 } 2212 i -= size 2213 i = encodeVarint(dAtA, i, uint64(size)) 2214 i-- 2215 dAtA[i] = 0xa 2216 } 2217 return len(dAtA) - i, nil 2218 } 2219 2220 func (m *ConcludeTransactionResponse) MarshalVT() (dAtA []byte, err error) { 2221 if m == nil { 2222 return nil, nil 2223 } 2224 size := m.SizeVT() 2225 dAtA = make([]byte, size) 2226 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 2227 if err != nil { 2228 return nil, err 2229 } 2230 return dAtA[:n], nil 2231 } 2232 2233 func (m *ConcludeTransactionResponse) MarshalToVT(dAtA []byte) (int, error) { 2234 size := m.SizeVT() 2235 return m.MarshalToSizedBufferVT(dAtA[:size]) 2236 } 2237 2238 func (m *ConcludeTransactionResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 2239 if m == nil { 2240 return 0, nil 2241 } 2242 i := len(dAtA) 2243 _ = i 2244 var l int 2245 _ = l 2246 if m.unknownFields != nil { 2247 i -= len(m.unknownFields) 2248 copy(dAtA[i:], m.unknownFields) 2249 } 2250 return len(dAtA) - i, nil 2251 } 2252 2253 func (m *ReadTransactionRequest) MarshalVT() (dAtA []byte, err error) { 2254 if m == nil { 2255 return nil, nil 2256 } 2257 size := m.SizeVT() 2258 dAtA = make([]byte, size) 2259 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 2260 if err != nil { 2261 return nil, err 2262 } 2263 return dAtA[:n], nil 2264 } 2265 2266 func (m *ReadTransactionRequest) MarshalToVT(dAtA []byte) (int, error) { 2267 size := m.SizeVT() 2268 return m.MarshalToSizedBufferVT(dAtA[:size]) 2269 } 2270 2271 func (m *ReadTransactionRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 2272 if m == nil { 2273 return 0, nil 2274 } 2275 i := len(dAtA) 2276 _ = i 2277 var l int 2278 _ = l 2279 if m.unknownFields != nil { 2280 i -= len(m.unknownFields) 2281 copy(dAtA[i:], m.unknownFields) 2282 } 2283 if len(m.Dtid) > 0 { 2284 i -= len(m.Dtid) 2285 copy(dAtA[i:], m.Dtid) 2286 i = encodeVarint(dAtA, i, uint64(len(m.Dtid))) 2287 i-- 2288 dAtA[i] = 0x22 2289 } 2290 if m.Target != nil { 2291 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 2292 if err != nil { 2293 return 0, err 2294 } 2295 i -= size 2296 i = encodeVarint(dAtA, i, uint64(size)) 2297 i-- 2298 dAtA[i] = 0x1a 2299 } 2300 if m.ImmediateCallerId != nil { 2301 size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i]) 2302 if err != nil { 2303 return 0, err 2304 } 2305 i -= size 2306 i = encodeVarint(dAtA, i, uint64(size)) 2307 i-- 2308 dAtA[i] = 0x12 2309 } 2310 if m.EffectiveCallerId != nil { 2311 size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i]) 2312 if err != nil { 2313 return 0, err 2314 } 2315 i -= size 2316 i = encodeVarint(dAtA, i, uint64(size)) 2317 i-- 2318 dAtA[i] = 0xa 2319 } 2320 return len(dAtA) - i, nil 2321 } 2322 2323 func (m *ReadTransactionResponse) MarshalVT() (dAtA []byte, err error) { 2324 if m == nil { 2325 return nil, nil 2326 } 2327 size := m.SizeVT() 2328 dAtA = make([]byte, size) 2329 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 2330 if err != nil { 2331 return nil, err 2332 } 2333 return dAtA[:n], nil 2334 } 2335 2336 func (m *ReadTransactionResponse) MarshalToVT(dAtA []byte) (int, error) { 2337 size := m.SizeVT() 2338 return m.MarshalToSizedBufferVT(dAtA[:size]) 2339 } 2340 2341 func (m *ReadTransactionResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 2342 if m == nil { 2343 return 0, nil 2344 } 2345 i := len(dAtA) 2346 _ = i 2347 var l int 2348 _ = l 2349 if m.unknownFields != nil { 2350 i -= len(m.unknownFields) 2351 copy(dAtA[i:], m.unknownFields) 2352 } 2353 if m.Metadata != nil { 2354 size, err := m.Metadata.MarshalToSizedBufferVT(dAtA[:i]) 2355 if err != nil { 2356 return 0, err 2357 } 2358 i -= size 2359 i = encodeVarint(dAtA, i, uint64(size)) 2360 i-- 2361 dAtA[i] = 0xa 2362 } 2363 return len(dAtA) - i, nil 2364 } 2365 2366 func (m *BeginExecuteRequest) MarshalVT() (dAtA []byte, err error) { 2367 if m == nil { 2368 return nil, nil 2369 } 2370 size := m.SizeVT() 2371 dAtA = make([]byte, size) 2372 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 2373 if err != nil { 2374 return nil, err 2375 } 2376 return dAtA[:n], nil 2377 } 2378 2379 func (m *BeginExecuteRequest) MarshalToVT(dAtA []byte) (int, error) { 2380 size := m.SizeVT() 2381 return m.MarshalToSizedBufferVT(dAtA[:size]) 2382 } 2383 2384 func (m *BeginExecuteRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 2385 if m == nil { 2386 return 0, nil 2387 } 2388 i := len(dAtA) 2389 _ = i 2390 var l int 2391 _ = l 2392 if m.unknownFields != nil { 2393 i -= len(m.unknownFields) 2394 copy(dAtA[i:], m.unknownFields) 2395 } 2396 if len(m.PreQueries) > 0 { 2397 for iNdEx := len(m.PreQueries) - 1; iNdEx >= 0; iNdEx-- { 2398 i -= len(m.PreQueries[iNdEx]) 2399 copy(dAtA[i:], m.PreQueries[iNdEx]) 2400 i = encodeVarint(dAtA, i, uint64(len(m.PreQueries[iNdEx]))) 2401 i-- 2402 dAtA[i] = 0x3a 2403 } 2404 } 2405 if m.ReservedId != 0 { 2406 i = encodeVarint(dAtA, i, uint64(m.ReservedId)) 2407 i-- 2408 dAtA[i] = 0x30 2409 } 2410 if m.Options != nil { 2411 size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i]) 2412 if err != nil { 2413 return 0, err 2414 } 2415 i -= size 2416 i = encodeVarint(dAtA, i, uint64(size)) 2417 i-- 2418 dAtA[i] = 0x2a 2419 } 2420 if m.Query != nil { 2421 size, err := m.Query.MarshalToSizedBufferVT(dAtA[:i]) 2422 if err != nil { 2423 return 0, err 2424 } 2425 i -= size 2426 i = encodeVarint(dAtA, i, uint64(size)) 2427 i-- 2428 dAtA[i] = 0x22 2429 } 2430 if m.Target != nil { 2431 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 2432 if err != nil { 2433 return 0, err 2434 } 2435 i -= size 2436 i = encodeVarint(dAtA, i, uint64(size)) 2437 i-- 2438 dAtA[i] = 0x1a 2439 } 2440 if m.ImmediateCallerId != nil { 2441 size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i]) 2442 if err != nil { 2443 return 0, err 2444 } 2445 i -= size 2446 i = encodeVarint(dAtA, i, uint64(size)) 2447 i-- 2448 dAtA[i] = 0x12 2449 } 2450 if m.EffectiveCallerId != nil { 2451 size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i]) 2452 if err != nil { 2453 return 0, err 2454 } 2455 i -= size 2456 i = encodeVarint(dAtA, i, uint64(size)) 2457 i-- 2458 dAtA[i] = 0xa 2459 } 2460 return len(dAtA) - i, nil 2461 } 2462 2463 func (m *BeginExecuteResponse) MarshalVT() (dAtA []byte, err error) { 2464 if m == nil { 2465 return nil, nil 2466 } 2467 size := m.SizeVT() 2468 dAtA = make([]byte, size) 2469 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 2470 if err != nil { 2471 return nil, err 2472 } 2473 return dAtA[:n], nil 2474 } 2475 2476 func (m *BeginExecuteResponse) MarshalToVT(dAtA []byte) (int, error) { 2477 size := m.SizeVT() 2478 return m.MarshalToSizedBufferVT(dAtA[:size]) 2479 } 2480 2481 func (m *BeginExecuteResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 2482 if m == nil { 2483 return 0, nil 2484 } 2485 i := len(dAtA) 2486 _ = i 2487 var l int 2488 _ = l 2489 if m.unknownFields != nil { 2490 i -= len(m.unknownFields) 2491 copy(dAtA[i:], m.unknownFields) 2492 } 2493 if m.TabletAlias != nil { 2494 size, err := m.TabletAlias.MarshalToSizedBufferVT(dAtA[:i]) 2495 if err != nil { 2496 return 0, err 2497 } 2498 i -= size 2499 i = encodeVarint(dAtA, i, uint64(size)) 2500 i-- 2501 dAtA[i] = 0x22 2502 } 2503 if m.TransactionId != 0 { 2504 i = encodeVarint(dAtA, i, uint64(m.TransactionId)) 2505 i-- 2506 dAtA[i] = 0x18 2507 } 2508 if m.Result != nil { 2509 size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i]) 2510 if err != nil { 2511 return 0, err 2512 } 2513 i -= size 2514 i = encodeVarint(dAtA, i, uint64(size)) 2515 i-- 2516 dAtA[i] = 0x12 2517 } 2518 if m.Error != nil { 2519 size, err := m.Error.MarshalToSizedBufferVT(dAtA[:i]) 2520 if err != nil { 2521 return 0, err 2522 } 2523 i -= size 2524 i = encodeVarint(dAtA, i, uint64(size)) 2525 i-- 2526 dAtA[i] = 0xa 2527 } 2528 return len(dAtA) - i, nil 2529 } 2530 2531 func (m *BeginStreamExecuteRequest) MarshalVT() (dAtA []byte, err error) { 2532 if m == nil { 2533 return nil, nil 2534 } 2535 size := m.SizeVT() 2536 dAtA = make([]byte, size) 2537 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 2538 if err != nil { 2539 return nil, err 2540 } 2541 return dAtA[:n], nil 2542 } 2543 2544 func (m *BeginStreamExecuteRequest) MarshalToVT(dAtA []byte) (int, error) { 2545 size := m.SizeVT() 2546 return m.MarshalToSizedBufferVT(dAtA[:size]) 2547 } 2548 2549 func (m *BeginStreamExecuteRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 2550 if m == nil { 2551 return 0, nil 2552 } 2553 i := len(dAtA) 2554 _ = i 2555 var l int 2556 _ = l 2557 if m.unknownFields != nil { 2558 i -= len(m.unknownFields) 2559 copy(dAtA[i:], m.unknownFields) 2560 } 2561 if m.ReservedId != 0 { 2562 i = encodeVarint(dAtA, i, uint64(m.ReservedId)) 2563 i-- 2564 dAtA[i] = 0x38 2565 } 2566 if len(m.PreQueries) > 0 { 2567 for iNdEx := len(m.PreQueries) - 1; iNdEx >= 0; iNdEx-- { 2568 i -= len(m.PreQueries[iNdEx]) 2569 copy(dAtA[i:], m.PreQueries[iNdEx]) 2570 i = encodeVarint(dAtA, i, uint64(len(m.PreQueries[iNdEx]))) 2571 i-- 2572 dAtA[i] = 0x32 2573 } 2574 } 2575 if m.Options != nil { 2576 size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i]) 2577 if err != nil { 2578 return 0, err 2579 } 2580 i -= size 2581 i = encodeVarint(dAtA, i, uint64(size)) 2582 i-- 2583 dAtA[i] = 0x2a 2584 } 2585 if m.Query != nil { 2586 size, err := m.Query.MarshalToSizedBufferVT(dAtA[:i]) 2587 if err != nil { 2588 return 0, err 2589 } 2590 i -= size 2591 i = encodeVarint(dAtA, i, uint64(size)) 2592 i-- 2593 dAtA[i] = 0x22 2594 } 2595 if m.Target != nil { 2596 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 2597 if err != nil { 2598 return 0, err 2599 } 2600 i -= size 2601 i = encodeVarint(dAtA, i, uint64(size)) 2602 i-- 2603 dAtA[i] = 0x1a 2604 } 2605 if m.ImmediateCallerId != nil { 2606 size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i]) 2607 if err != nil { 2608 return 0, err 2609 } 2610 i -= size 2611 i = encodeVarint(dAtA, i, uint64(size)) 2612 i-- 2613 dAtA[i] = 0x12 2614 } 2615 if m.EffectiveCallerId != nil { 2616 size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i]) 2617 if err != nil { 2618 return 0, err 2619 } 2620 i -= size 2621 i = encodeVarint(dAtA, i, uint64(size)) 2622 i-- 2623 dAtA[i] = 0xa 2624 } 2625 return len(dAtA) - i, nil 2626 } 2627 2628 func (m *BeginStreamExecuteResponse) MarshalVT() (dAtA []byte, err error) { 2629 if m == nil { 2630 return nil, nil 2631 } 2632 size := m.SizeVT() 2633 dAtA = make([]byte, size) 2634 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 2635 if err != nil { 2636 return nil, err 2637 } 2638 return dAtA[:n], nil 2639 } 2640 2641 func (m *BeginStreamExecuteResponse) MarshalToVT(dAtA []byte) (int, error) { 2642 size := m.SizeVT() 2643 return m.MarshalToSizedBufferVT(dAtA[:size]) 2644 } 2645 2646 func (m *BeginStreamExecuteResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 2647 if m == nil { 2648 return 0, nil 2649 } 2650 i := len(dAtA) 2651 _ = i 2652 var l int 2653 _ = l 2654 if m.unknownFields != nil { 2655 i -= len(m.unknownFields) 2656 copy(dAtA[i:], m.unknownFields) 2657 } 2658 if m.TabletAlias != nil { 2659 size, err := m.TabletAlias.MarshalToSizedBufferVT(dAtA[:i]) 2660 if err != nil { 2661 return 0, err 2662 } 2663 i -= size 2664 i = encodeVarint(dAtA, i, uint64(size)) 2665 i-- 2666 dAtA[i] = 0x22 2667 } 2668 if m.TransactionId != 0 { 2669 i = encodeVarint(dAtA, i, uint64(m.TransactionId)) 2670 i-- 2671 dAtA[i] = 0x18 2672 } 2673 if m.Result != nil { 2674 size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i]) 2675 if err != nil { 2676 return 0, err 2677 } 2678 i -= size 2679 i = encodeVarint(dAtA, i, uint64(size)) 2680 i-- 2681 dAtA[i] = 0x12 2682 } 2683 if m.Error != nil { 2684 size, err := m.Error.MarshalToSizedBufferVT(dAtA[:i]) 2685 if err != nil { 2686 return 0, err 2687 } 2688 i -= size 2689 i = encodeVarint(dAtA, i, uint64(size)) 2690 i-- 2691 dAtA[i] = 0xa 2692 } 2693 return len(dAtA) - i, nil 2694 } 2695 2696 func (m *MessageStreamRequest) MarshalVT() (dAtA []byte, err error) { 2697 if m == nil { 2698 return nil, nil 2699 } 2700 size := m.SizeVT() 2701 dAtA = make([]byte, size) 2702 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 2703 if err != nil { 2704 return nil, err 2705 } 2706 return dAtA[:n], nil 2707 } 2708 2709 func (m *MessageStreamRequest) MarshalToVT(dAtA []byte) (int, error) { 2710 size := m.SizeVT() 2711 return m.MarshalToSizedBufferVT(dAtA[:size]) 2712 } 2713 2714 func (m *MessageStreamRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 2715 if m == nil { 2716 return 0, nil 2717 } 2718 i := len(dAtA) 2719 _ = i 2720 var l int 2721 _ = l 2722 if m.unknownFields != nil { 2723 i -= len(m.unknownFields) 2724 copy(dAtA[i:], m.unknownFields) 2725 } 2726 if len(m.Name) > 0 { 2727 i -= len(m.Name) 2728 copy(dAtA[i:], m.Name) 2729 i = encodeVarint(dAtA, i, uint64(len(m.Name))) 2730 i-- 2731 dAtA[i] = 0x22 2732 } 2733 if m.Target != nil { 2734 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 2735 if err != nil { 2736 return 0, err 2737 } 2738 i -= size 2739 i = encodeVarint(dAtA, i, uint64(size)) 2740 i-- 2741 dAtA[i] = 0x1a 2742 } 2743 if m.ImmediateCallerId != nil { 2744 size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i]) 2745 if err != nil { 2746 return 0, err 2747 } 2748 i -= size 2749 i = encodeVarint(dAtA, i, uint64(size)) 2750 i-- 2751 dAtA[i] = 0x12 2752 } 2753 if m.EffectiveCallerId != nil { 2754 size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i]) 2755 if err != nil { 2756 return 0, err 2757 } 2758 i -= size 2759 i = encodeVarint(dAtA, i, uint64(size)) 2760 i-- 2761 dAtA[i] = 0xa 2762 } 2763 return len(dAtA) - i, nil 2764 } 2765 2766 func (m *MessageStreamResponse) MarshalVT() (dAtA []byte, err error) { 2767 if m == nil { 2768 return nil, nil 2769 } 2770 size := m.SizeVT() 2771 dAtA = make([]byte, size) 2772 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 2773 if err != nil { 2774 return nil, err 2775 } 2776 return dAtA[:n], nil 2777 } 2778 2779 func (m *MessageStreamResponse) MarshalToVT(dAtA []byte) (int, error) { 2780 size := m.SizeVT() 2781 return m.MarshalToSizedBufferVT(dAtA[:size]) 2782 } 2783 2784 func (m *MessageStreamResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 2785 if m == nil { 2786 return 0, nil 2787 } 2788 i := len(dAtA) 2789 _ = i 2790 var l int 2791 _ = l 2792 if m.unknownFields != nil { 2793 i -= len(m.unknownFields) 2794 copy(dAtA[i:], m.unknownFields) 2795 } 2796 if m.Result != nil { 2797 size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i]) 2798 if err != nil { 2799 return 0, err 2800 } 2801 i -= size 2802 i = encodeVarint(dAtA, i, uint64(size)) 2803 i-- 2804 dAtA[i] = 0xa 2805 } 2806 return len(dAtA) - i, nil 2807 } 2808 2809 func (m *MessageAckRequest) MarshalVT() (dAtA []byte, err error) { 2810 if m == nil { 2811 return nil, nil 2812 } 2813 size := m.SizeVT() 2814 dAtA = make([]byte, size) 2815 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 2816 if err != nil { 2817 return nil, err 2818 } 2819 return dAtA[:n], nil 2820 } 2821 2822 func (m *MessageAckRequest) MarshalToVT(dAtA []byte) (int, error) { 2823 size := m.SizeVT() 2824 return m.MarshalToSizedBufferVT(dAtA[:size]) 2825 } 2826 2827 func (m *MessageAckRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 2828 if m == nil { 2829 return 0, nil 2830 } 2831 i := len(dAtA) 2832 _ = i 2833 var l int 2834 _ = l 2835 if m.unknownFields != nil { 2836 i -= len(m.unknownFields) 2837 copy(dAtA[i:], m.unknownFields) 2838 } 2839 if len(m.Ids) > 0 { 2840 for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- { 2841 size, err := m.Ids[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) 2842 if err != nil { 2843 return 0, err 2844 } 2845 i -= size 2846 i = encodeVarint(dAtA, i, uint64(size)) 2847 i-- 2848 dAtA[i] = 0x2a 2849 } 2850 } 2851 if len(m.Name) > 0 { 2852 i -= len(m.Name) 2853 copy(dAtA[i:], m.Name) 2854 i = encodeVarint(dAtA, i, uint64(len(m.Name))) 2855 i-- 2856 dAtA[i] = 0x22 2857 } 2858 if m.Target != nil { 2859 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 2860 if err != nil { 2861 return 0, err 2862 } 2863 i -= size 2864 i = encodeVarint(dAtA, i, uint64(size)) 2865 i-- 2866 dAtA[i] = 0x1a 2867 } 2868 if m.ImmediateCallerId != nil { 2869 size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i]) 2870 if err != nil { 2871 return 0, err 2872 } 2873 i -= size 2874 i = encodeVarint(dAtA, i, uint64(size)) 2875 i-- 2876 dAtA[i] = 0x12 2877 } 2878 if m.EffectiveCallerId != nil { 2879 size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i]) 2880 if err != nil { 2881 return 0, err 2882 } 2883 i -= size 2884 i = encodeVarint(dAtA, i, uint64(size)) 2885 i-- 2886 dAtA[i] = 0xa 2887 } 2888 return len(dAtA) - i, nil 2889 } 2890 2891 func (m *MessageAckResponse) MarshalVT() (dAtA []byte, err error) { 2892 if m == nil { 2893 return nil, nil 2894 } 2895 size := m.SizeVT() 2896 dAtA = make([]byte, size) 2897 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 2898 if err != nil { 2899 return nil, err 2900 } 2901 return dAtA[:n], nil 2902 } 2903 2904 func (m *MessageAckResponse) MarshalToVT(dAtA []byte) (int, error) { 2905 size := m.SizeVT() 2906 return m.MarshalToSizedBufferVT(dAtA[:size]) 2907 } 2908 2909 func (m *MessageAckResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 2910 if m == nil { 2911 return 0, nil 2912 } 2913 i := len(dAtA) 2914 _ = i 2915 var l int 2916 _ = l 2917 if m.unknownFields != nil { 2918 i -= len(m.unknownFields) 2919 copy(dAtA[i:], m.unknownFields) 2920 } 2921 if m.Result != nil { 2922 size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i]) 2923 if err != nil { 2924 return 0, err 2925 } 2926 i -= size 2927 i = encodeVarint(dAtA, i, uint64(size)) 2928 i-- 2929 dAtA[i] = 0xa 2930 } 2931 return len(dAtA) - i, nil 2932 } 2933 2934 func (m *ReserveExecuteRequest) MarshalVT() (dAtA []byte, err error) { 2935 if m == nil { 2936 return nil, nil 2937 } 2938 size := m.SizeVT() 2939 dAtA = make([]byte, size) 2940 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 2941 if err != nil { 2942 return nil, err 2943 } 2944 return dAtA[:n], nil 2945 } 2946 2947 func (m *ReserveExecuteRequest) MarshalToVT(dAtA []byte) (int, error) { 2948 size := m.SizeVT() 2949 return m.MarshalToSizedBufferVT(dAtA[:size]) 2950 } 2951 2952 func (m *ReserveExecuteRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 2953 if m == nil { 2954 return 0, nil 2955 } 2956 i := len(dAtA) 2957 _ = i 2958 var l int 2959 _ = l 2960 if m.unknownFields != nil { 2961 i -= len(m.unknownFields) 2962 copy(dAtA[i:], m.unknownFields) 2963 } 2964 if len(m.PreQueries) > 0 { 2965 for iNdEx := len(m.PreQueries) - 1; iNdEx >= 0; iNdEx-- { 2966 i -= len(m.PreQueries[iNdEx]) 2967 copy(dAtA[i:], m.PreQueries[iNdEx]) 2968 i = encodeVarint(dAtA, i, uint64(len(m.PreQueries[iNdEx]))) 2969 i-- 2970 dAtA[i] = 0x3a 2971 } 2972 } 2973 if m.Options != nil { 2974 size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i]) 2975 if err != nil { 2976 return 0, err 2977 } 2978 i -= size 2979 i = encodeVarint(dAtA, i, uint64(size)) 2980 i-- 2981 dAtA[i] = 0x32 2982 } 2983 if m.TransactionId != 0 { 2984 i = encodeVarint(dAtA, i, uint64(m.TransactionId)) 2985 i-- 2986 dAtA[i] = 0x28 2987 } 2988 if m.Query != nil { 2989 size, err := m.Query.MarshalToSizedBufferVT(dAtA[:i]) 2990 if err != nil { 2991 return 0, err 2992 } 2993 i -= size 2994 i = encodeVarint(dAtA, i, uint64(size)) 2995 i-- 2996 dAtA[i] = 0x22 2997 } 2998 if m.Target != nil { 2999 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 3000 if err != nil { 3001 return 0, err 3002 } 3003 i -= size 3004 i = encodeVarint(dAtA, i, uint64(size)) 3005 i-- 3006 dAtA[i] = 0x1a 3007 } 3008 if m.ImmediateCallerId != nil { 3009 size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i]) 3010 if err != nil { 3011 return 0, err 3012 } 3013 i -= size 3014 i = encodeVarint(dAtA, i, uint64(size)) 3015 i-- 3016 dAtA[i] = 0x12 3017 } 3018 if m.EffectiveCallerId != nil { 3019 size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i]) 3020 if err != nil { 3021 return 0, err 3022 } 3023 i -= size 3024 i = encodeVarint(dAtA, i, uint64(size)) 3025 i-- 3026 dAtA[i] = 0xa 3027 } 3028 return len(dAtA) - i, nil 3029 } 3030 3031 func (m *ReserveExecuteResponse) MarshalVT() (dAtA []byte, err error) { 3032 if m == nil { 3033 return nil, nil 3034 } 3035 size := m.SizeVT() 3036 dAtA = make([]byte, size) 3037 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 3038 if err != nil { 3039 return nil, err 3040 } 3041 return dAtA[:n], nil 3042 } 3043 3044 func (m *ReserveExecuteResponse) MarshalToVT(dAtA []byte) (int, error) { 3045 size := m.SizeVT() 3046 return m.MarshalToSizedBufferVT(dAtA[:size]) 3047 } 3048 3049 func (m *ReserveExecuteResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 3050 if m == nil { 3051 return 0, nil 3052 } 3053 i := len(dAtA) 3054 _ = i 3055 var l int 3056 _ = l 3057 if m.unknownFields != nil { 3058 i -= len(m.unknownFields) 3059 copy(dAtA[i:], m.unknownFields) 3060 } 3061 if m.TabletAlias != nil { 3062 size, err := m.TabletAlias.MarshalToSizedBufferVT(dAtA[:i]) 3063 if err != nil { 3064 return 0, err 3065 } 3066 i -= size 3067 i = encodeVarint(dAtA, i, uint64(size)) 3068 i-- 3069 dAtA[i] = 0x22 3070 } 3071 if m.ReservedId != 0 { 3072 i = encodeVarint(dAtA, i, uint64(m.ReservedId)) 3073 i-- 3074 dAtA[i] = 0x18 3075 } 3076 if m.Result != nil { 3077 size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i]) 3078 if err != nil { 3079 return 0, err 3080 } 3081 i -= size 3082 i = encodeVarint(dAtA, i, uint64(size)) 3083 i-- 3084 dAtA[i] = 0x12 3085 } 3086 if m.Error != nil { 3087 size, err := m.Error.MarshalToSizedBufferVT(dAtA[:i]) 3088 if err != nil { 3089 return 0, err 3090 } 3091 i -= size 3092 i = encodeVarint(dAtA, i, uint64(size)) 3093 i-- 3094 dAtA[i] = 0xa 3095 } 3096 return len(dAtA) - i, nil 3097 } 3098 3099 func (m *ReserveStreamExecuteRequest) MarshalVT() (dAtA []byte, err error) { 3100 if m == nil { 3101 return nil, nil 3102 } 3103 size := m.SizeVT() 3104 dAtA = make([]byte, size) 3105 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 3106 if err != nil { 3107 return nil, err 3108 } 3109 return dAtA[:n], nil 3110 } 3111 3112 func (m *ReserveStreamExecuteRequest) MarshalToVT(dAtA []byte) (int, error) { 3113 size := m.SizeVT() 3114 return m.MarshalToSizedBufferVT(dAtA[:size]) 3115 } 3116 3117 func (m *ReserveStreamExecuteRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 3118 if m == nil { 3119 return 0, nil 3120 } 3121 i := len(dAtA) 3122 _ = i 3123 var l int 3124 _ = l 3125 if m.unknownFields != nil { 3126 i -= len(m.unknownFields) 3127 copy(dAtA[i:], m.unknownFields) 3128 } 3129 if len(m.PreQueries) > 0 { 3130 for iNdEx := len(m.PreQueries) - 1; iNdEx >= 0; iNdEx-- { 3131 i -= len(m.PreQueries[iNdEx]) 3132 copy(dAtA[i:], m.PreQueries[iNdEx]) 3133 i = encodeVarint(dAtA, i, uint64(len(m.PreQueries[iNdEx]))) 3134 i-- 3135 dAtA[i] = 0x3a 3136 } 3137 } 3138 if m.TransactionId != 0 { 3139 i = encodeVarint(dAtA, i, uint64(m.TransactionId)) 3140 i-- 3141 dAtA[i] = 0x30 3142 } 3143 if m.Options != nil { 3144 size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i]) 3145 if err != nil { 3146 return 0, err 3147 } 3148 i -= size 3149 i = encodeVarint(dAtA, i, uint64(size)) 3150 i-- 3151 dAtA[i] = 0x2a 3152 } 3153 if m.Query != nil { 3154 size, err := m.Query.MarshalToSizedBufferVT(dAtA[:i]) 3155 if err != nil { 3156 return 0, err 3157 } 3158 i -= size 3159 i = encodeVarint(dAtA, i, uint64(size)) 3160 i-- 3161 dAtA[i] = 0x22 3162 } 3163 if m.Target != nil { 3164 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 3165 if err != nil { 3166 return 0, err 3167 } 3168 i -= size 3169 i = encodeVarint(dAtA, i, uint64(size)) 3170 i-- 3171 dAtA[i] = 0x1a 3172 } 3173 if m.ImmediateCallerId != nil { 3174 size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i]) 3175 if err != nil { 3176 return 0, err 3177 } 3178 i -= size 3179 i = encodeVarint(dAtA, i, uint64(size)) 3180 i-- 3181 dAtA[i] = 0x12 3182 } 3183 if m.EffectiveCallerId != nil { 3184 size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i]) 3185 if err != nil { 3186 return 0, err 3187 } 3188 i -= size 3189 i = encodeVarint(dAtA, i, uint64(size)) 3190 i-- 3191 dAtA[i] = 0xa 3192 } 3193 return len(dAtA) - i, nil 3194 } 3195 3196 func (m *ReserveStreamExecuteResponse) MarshalVT() (dAtA []byte, err error) { 3197 if m == nil { 3198 return nil, nil 3199 } 3200 size := m.SizeVT() 3201 dAtA = make([]byte, size) 3202 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 3203 if err != nil { 3204 return nil, err 3205 } 3206 return dAtA[:n], nil 3207 } 3208 3209 func (m *ReserveStreamExecuteResponse) MarshalToVT(dAtA []byte) (int, error) { 3210 size := m.SizeVT() 3211 return m.MarshalToSizedBufferVT(dAtA[:size]) 3212 } 3213 3214 func (m *ReserveStreamExecuteResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 3215 if m == nil { 3216 return 0, nil 3217 } 3218 i := len(dAtA) 3219 _ = i 3220 var l int 3221 _ = l 3222 if m.unknownFields != nil { 3223 i -= len(m.unknownFields) 3224 copy(dAtA[i:], m.unknownFields) 3225 } 3226 if m.TabletAlias != nil { 3227 size, err := m.TabletAlias.MarshalToSizedBufferVT(dAtA[:i]) 3228 if err != nil { 3229 return 0, err 3230 } 3231 i -= size 3232 i = encodeVarint(dAtA, i, uint64(size)) 3233 i-- 3234 dAtA[i] = 0x22 3235 } 3236 if m.ReservedId != 0 { 3237 i = encodeVarint(dAtA, i, uint64(m.ReservedId)) 3238 i-- 3239 dAtA[i] = 0x18 3240 } 3241 if m.Result != nil { 3242 size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i]) 3243 if err != nil { 3244 return 0, err 3245 } 3246 i -= size 3247 i = encodeVarint(dAtA, i, uint64(size)) 3248 i-- 3249 dAtA[i] = 0x12 3250 } 3251 if m.Error != nil { 3252 size, err := m.Error.MarshalToSizedBufferVT(dAtA[:i]) 3253 if err != nil { 3254 return 0, err 3255 } 3256 i -= size 3257 i = encodeVarint(dAtA, i, uint64(size)) 3258 i-- 3259 dAtA[i] = 0xa 3260 } 3261 return len(dAtA) - i, nil 3262 } 3263 3264 func (m *ReserveBeginExecuteRequest) MarshalVT() (dAtA []byte, err error) { 3265 if m == nil { 3266 return nil, nil 3267 } 3268 size := m.SizeVT() 3269 dAtA = make([]byte, size) 3270 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 3271 if err != nil { 3272 return nil, err 3273 } 3274 return dAtA[:n], nil 3275 } 3276 3277 func (m *ReserveBeginExecuteRequest) MarshalToVT(dAtA []byte) (int, error) { 3278 size := m.SizeVT() 3279 return m.MarshalToSizedBufferVT(dAtA[:size]) 3280 } 3281 3282 func (m *ReserveBeginExecuteRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 3283 if m == nil { 3284 return 0, nil 3285 } 3286 i := len(dAtA) 3287 _ = i 3288 var l int 3289 _ = l 3290 if m.unknownFields != nil { 3291 i -= len(m.unknownFields) 3292 copy(dAtA[i:], m.unknownFields) 3293 } 3294 if len(m.PostBeginQueries) > 0 { 3295 for iNdEx := len(m.PostBeginQueries) - 1; iNdEx >= 0; iNdEx-- { 3296 i -= len(m.PostBeginQueries[iNdEx]) 3297 copy(dAtA[i:], m.PostBeginQueries[iNdEx]) 3298 i = encodeVarint(dAtA, i, uint64(len(m.PostBeginQueries[iNdEx]))) 3299 i-- 3300 dAtA[i] = 0x3a 3301 } 3302 } 3303 if len(m.PreQueries) > 0 { 3304 for iNdEx := len(m.PreQueries) - 1; iNdEx >= 0; iNdEx-- { 3305 i -= len(m.PreQueries[iNdEx]) 3306 copy(dAtA[i:], m.PreQueries[iNdEx]) 3307 i = encodeVarint(dAtA, i, uint64(len(m.PreQueries[iNdEx]))) 3308 i-- 3309 dAtA[i] = 0x32 3310 } 3311 } 3312 if m.Options != nil { 3313 size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i]) 3314 if err != nil { 3315 return 0, err 3316 } 3317 i -= size 3318 i = encodeVarint(dAtA, i, uint64(size)) 3319 i-- 3320 dAtA[i] = 0x2a 3321 } 3322 if m.Query != nil { 3323 size, err := m.Query.MarshalToSizedBufferVT(dAtA[:i]) 3324 if err != nil { 3325 return 0, err 3326 } 3327 i -= size 3328 i = encodeVarint(dAtA, i, uint64(size)) 3329 i-- 3330 dAtA[i] = 0x22 3331 } 3332 if m.Target != nil { 3333 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 3334 if err != nil { 3335 return 0, err 3336 } 3337 i -= size 3338 i = encodeVarint(dAtA, i, uint64(size)) 3339 i-- 3340 dAtA[i] = 0x1a 3341 } 3342 if m.ImmediateCallerId != nil { 3343 size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i]) 3344 if err != nil { 3345 return 0, err 3346 } 3347 i -= size 3348 i = encodeVarint(dAtA, i, uint64(size)) 3349 i-- 3350 dAtA[i] = 0x12 3351 } 3352 if m.EffectiveCallerId != nil { 3353 size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i]) 3354 if err != nil { 3355 return 0, err 3356 } 3357 i -= size 3358 i = encodeVarint(dAtA, i, uint64(size)) 3359 i-- 3360 dAtA[i] = 0xa 3361 } 3362 return len(dAtA) - i, nil 3363 } 3364 3365 func (m *ReserveBeginExecuteResponse) MarshalVT() (dAtA []byte, err error) { 3366 if m == nil { 3367 return nil, nil 3368 } 3369 size := m.SizeVT() 3370 dAtA = make([]byte, size) 3371 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 3372 if err != nil { 3373 return nil, err 3374 } 3375 return dAtA[:n], nil 3376 } 3377 3378 func (m *ReserveBeginExecuteResponse) MarshalToVT(dAtA []byte) (int, error) { 3379 size := m.SizeVT() 3380 return m.MarshalToSizedBufferVT(dAtA[:size]) 3381 } 3382 3383 func (m *ReserveBeginExecuteResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 3384 if m == nil { 3385 return 0, nil 3386 } 3387 i := len(dAtA) 3388 _ = i 3389 var l int 3390 _ = l 3391 if m.unknownFields != nil { 3392 i -= len(m.unknownFields) 3393 copy(dAtA[i:], m.unknownFields) 3394 } 3395 if m.TabletAlias != nil { 3396 size, err := m.TabletAlias.MarshalToSizedBufferVT(dAtA[:i]) 3397 if err != nil { 3398 return 0, err 3399 } 3400 i -= size 3401 i = encodeVarint(dAtA, i, uint64(size)) 3402 i-- 3403 dAtA[i] = 0x2a 3404 } 3405 if m.ReservedId != 0 { 3406 i = encodeVarint(dAtA, i, uint64(m.ReservedId)) 3407 i-- 3408 dAtA[i] = 0x20 3409 } 3410 if m.TransactionId != 0 { 3411 i = encodeVarint(dAtA, i, uint64(m.TransactionId)) 3412 i-- 3413 dAtA[i] = 0x18 3414 } 3415 if m.Result != nil { 3416 size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i]) 3417 if err != nil { 3418 return 0, err 3419 } 3420 i -= size 3421 i = encodeVarint(dAtA, i, uint64(size)) 3422 i-- 3423 dAtA[i] = 0x12 3424 } 3425 if m.Error != nil { 3426 size, err := m.Error.MarshalToSizedBufferVT(dAtA[:i]) 3427 if err != nil { 3428 return 0, err 3429 } 3430 i -= size 3431 i = encodeVarint(dAtA, i, uint64(size)) 3432 i-- 3433 dAtA[i] = 0xa 3434 } 3435 return len(dAtA) - i, nil 3436 } 3437 3438 func (m *ReserveBeginStreamExecuteRequest) MarshalVT() (dAtA []byte, err error) { 3439 if m == nil { 3440 return nil, nil 3441 } 3442 size := m.SizeVT() 3443 dAtA = make([]byte, size) 3444 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 3445 if err != nil { 3446 return nil, err 3447 } 3448 return dAtA[:n], nil 3449 } 3450 3451 func (m *ReserveBeginStreamExecuteRequest) MarshalToVT(dAtA []byte) (int, error) { 3452 size := m.SizeVT() 3453 return m.MarshalToSizedBufferVT(dAtA[:size]) 3454 } 3455 3456 func (m *ReserveBeginStreamExecuteRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 3457 if m == nil { 3458 return 0, nil 3459 } 3460 i := len(dAtA) 3461 _ = i 3462 var l int 3463 _ = l 3464 if m.unknownFields != nil { 3465 i -= len(m.unknownFields) 3466 copy(dAtA[i:], m.unknownFields) 3467 } 3468 if len(m.PostBeginQueries) > 0 { 3469 for iNdEx := len(m.PostBeginQueries) - 1; iNdEx >= 0; iNdEx-- { 3470 i -= len(m.PostBeginQueries[iNdEx]) 3471 copy(dAtA[i:], m.PostBeginQueries[iNdEx]) 3472 i = encodeVarint(dAtA, i, uint64(len(m.PostBeginQueries[iNdEx]))) 3473 i-- 3474 dAtA[i] = 0x3a 3475 } 3476 } 3477 if len(m.PreQueries) > 0 { 3478 for iNdEx := len(m.PreQueries) - 1; iNdEx >= 0; iNdEx-- { 3479 i -= len(m.PreQueries[iNdEx]) 3480 copy(dAtA[i:], m.PreQueries[iNdEx]) 3481 i = encodeVarint(dAtA, i, uint64(len(m.PreQueries[iNdEx]))) 3482 i-- 3483 dAtA[i] = 0x32 3484 } 3485 } 3486 if m.Options != nil { 3487 size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i]) 3488 if err != nil { 3489 return 0, err 3490 } 3491 i -= size 3492 i = encodeVarint(dAtA, i, uint64(size)) 3493 i-- 3494 dAtA[i] = 0x2a 3495 } 3496 if m.Query != nil { 3497 size, err := m.Query.MarshalToSizedBufferVT(dAtA[:i]) 3498 if err != nil { 3499 return 0, err 3500 } 3501 i -= size 3502 i = encodeVarint(dAtA, i, uint64(size)) 3503 i-- 3504 dAtA[i] = 0x22 3505 } 3506 if m.Target != nil { 3507 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 3508 if err != nil { 3509 return 0, err 3510 } 3511 i -= size 3512 i = encodeVarint(dAtA, i, uint64(size)) 3513 i-- 3514 dAtA[i] = 0x1a 3515 } 3516 if m.ImmediateCallerId != nil { 3517 size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i]) 3518 if err != nil { 3519 return 0, err 3520 } 3521 i -= size 3522 i = encodeVarint(dAtA, i, uint64(size)) 3523 i-- 3524 dAtA[i] = 0x12 3525 } 3526 if m.EffectiveCallerId != nil { 3527 size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i]) 3528 if err != nil { 3529 return 0, err 3530 } 3531 i -= size 3532 i = encodeVarint(dAtA, i, uint64(size)) 3533 i-- 3534 dAtA[i] = 0xa 3535 } 3536 return len(dAtA) - i, nil 3537 } 3538 3539 func (m *ReserveBeginStreamExecuteResponse) MarshalVT() (dAtA []byte, err error) { 3540 if m == nil { 3541 return nil, nil 3542 } 3543 size := m.SizeVT() 3544 dAtA = make([]byte, size) 3545 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 3546 if err != nil { 3547 return nil, err 3548 } 3549 return dAtA[:n], nil 3550 } 3551 3552 func (m *ReserveBeginStreamExecuteResponse) MarshalToVT(dAtA []byte) (int, error) { 3553 size := m.SizeVT() 3554 return m.MarshalToSizedBufferVT(dAtA[:size]) 3555 } 3556 3557 func (m *ReserveBeginStreamExecuteResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 3558 if m == nil { 3559 return 0, nil 3560 } 3561 i := len(dAtA) 3562 _ = i 3563 var l int 3564 _ = l 3565 if m.unknownFields != nil { 3566 i -= len(m.unknownFields) 3567 copy(dAtA[i:], m.unknownFields) 3568 } 3569 if m.TabletAlias != nil { 3570 size, err := m.TabletAlias.MarshalToSizedBufferVT(dAtA[:i]) 3571 if err != nil { 3572 return 0, err 3573 } 3574 i -= size 3575 i = encodeVarint(dAtA, i, uint64(size)) 3576 i-- 3577 dAtA[i] = 0x2a 3578 } 3579 if m.ReservedId != 0 { 3580 i = encodeVarint(dAtA, i, uint64(m.ReservedId)) 3581 i-- 3582 dAtA[i] = 0x20 3583 } 3584 if m.TransactionId != 0 { 3585 i = encodeVarint(dAtA, i, uint64(m.TransactionId)) 3586 i-- 3587 dAtA[i] = 0x18 3588 } 3589 if m.Result != nil { 3590 size, err := m.Result.MarshalToSizedBufferVT(dAtA[:i]) 3591 if err != nil { 3592 return 0, err 3593 } 3594 i -= size 3595 i = encodeVarint(dAtA, i, uint64(size)) 3596 i-- 3597 dAtA[i] = 0x12 3598 } 3599 if m.Error != nil { 3600 size, err := m.Error.MarshalToSizedBufferVT(dAtA[:i]) 3601 if err != nil { 3602 return 0, err 3603 } 3604 i -= size 3605 i = encodeVarint(dAtA, i, uint64(size)) 3606 i-- 3607 dAtA[i] = 0xa 3608 } 3609 return len(dAtA) - i, nil 3610 } 3611 3612 func (m *ReleaseRequest) MarshalVT() (dAtA []byte, err error) { 3613 if m == nil { 3614 return nil, nil 3615 } 3616 size := m.SizeVT() 3617 dAtA = make([]byte, size) 3618 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 3619 if err != nil { 3620 return nil, err 3621 } 3622 return dAtA[:n], nil 3623 } 3624 3625 func (m *ReleaseRequest) MarshalToVT(dAtA []byte) (int, error) { 3626 size := m.SizeVT() 3627 return m.MarshalToSizedBufferVT(dAtA[:size]) 3628 } 3629 3630 func (m *ReleaseRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 3631 if m == nil { 3632 return 0, nil 3633 } 3634 i := len(dAtA) 3635 _ = i 3636 var l int 3637 _ = l 3638 if m.unknownFields != nil { 3639 i -= len(m.unknownFields) 3640 copy(dAtA[i:], m.unknownFields) 3641 } 3642 if m.ReservedId != 0 { 3643 i = encodeVarint(dAtA, i, uint64(m.ReservedId)) 3644 i-- 3645 dAtA[i] = 0x28 3646 } 3647 if m.TransactionId != 0 { 3648 i = encodeVarint(dAtA, i, uint64(m.TransactionId)) 3649 i-- 3650 dAtA[i] = 0x20 3651 } 3652 if m.Target != nil { 3653 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 3654 if err != nil { 3655 return 0, err 3656 } 3657 i -= size 3658 i = encodeVarint(dAtA, i, uint64(size)) 3659 i-- 3660 dAtA[i] = 0x1a 3661 } 3662 if m.ImmediateCallerId != nil { 3663 size, err := m.ImmediateCallerId.MarshalToSizedBufferVT(dAtA[:i]) 3664 if err != nil { 3665 return 0, err 3666 } 3667 i -= size 3668 i = encodeVarint(dAtA, i, uint64(size)) 3669 i-- 3670 dAtA[i] = 0x12 3671 } 3672 if m.EffectiveCallerId != nil { 3673 size, err := m.EffectiveCallerId.MarshalToSizedBufferVT(dAtA[:i]) 3674 if err != nil { 3675 return 0, err 3676 } 3677 i -= size 3678 i = encodeVarint(dAtA, i, uint64(size)) 3679 i-- 3680 dAtA[i] = 0xa 3681 } 3682 return len(dAtA) - i, nil 3683 } 3684 3685 func (m *ReleaseResponse) MarshalVT() (dAtA []byte, err error) { 3686 if m == nil { 3687 return nil, nil 3688 } 3689 size := m.SizeVT() 3690 dAtA = make([]byte, size) 3691 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 3692 if err != nil { 3693 return nil, err 3694 } 3695 return dAtA[:n], nil 3696 } 3697 3698 func (m *ReleaseResponse) MarshalToVT(dAtA []byte) (int, error) { 3699 size := m.SizeVT() 3700 return m.MarshalToSizedBufferVT(dAtA[:size]) 3701 } 3702 3703 func (m *ReleaseResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 3704 if m == nil { 3705 return 0, nil 3706 } 3707 i := len(dAtA) 3708 _ = i 3709 var l int 3710 _ = l 3711 if m.unknownFields != nil { 3712 i -= len(m.unknownFields) 3713 copy(dAtA[i:], m.unknownFields) 3714 } 3715 return len(dAtA) - i, nil 3716 } 3717 3718 func (m *StreamHealthRequest) MarshalVT() (dAtA []byte, err error) { 3719 if m == nil { 3720 return nil, nil 3721 } 3722 size := m.SizeVT() 3723 dAtA = make([]byte, size) 3724 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 3725 if err != nil { 3726 return nil, err 3727 } 3728 return dAtA[:n], nil 3729 } 3730 3731 func (m *StreamHealthRequest) MarshalToVT(dAtA []byte) (int, error) { 3732 size := m.SizeVT() 3733 return m.MarshalToSizedBufferVT(dAtA[:size]) 3734 } 3735 3736 func (m *StreamHealthRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 3737 if m == nil { 3738 return 0, nil 3739 } 3740 i := len(dAtA) 3741 _ = i 3742 var l int 3743 _ = l 3744 if m.unknownFields != nil { 3745 i -= len(m.unknownFields) 3746 copy(dAtA[i:], m.unknownFields) 3747 } 3748 return len(dAtA) - i, nil 3749 } 3750 3751 func (m *RealtimeStats) MarshalVT() (dAtA []byte, err error) { 3752 if m == nil { 3753 return nil, nil 3754 } 3755 size := m.SizeVT() 3756 dAtA = make([]byte, size) 3757 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 3758 if err != nil { 3759 return nil, err 3760 } 3761 return dAtA[:n], nil 3762 } 3763 3764 func (m *RealtimeStats) MarshalToVT(dAtA []byte) (int, error) { 3765 size := m.SizeVT() 3766 return m.MarshalToSizedBufferVT(dAtA[:size]) 3767 } 3768 3769 func (m *RealtimeStats) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 3770 if m == nil { 3771 return 0, nil 3772 } 3773 i := len(dAtA) 3774 _ = i 3775 var l int 3776 _ = l 3777 if m.unknownFields != nil { 3778 i -= len(m.unknownFields) 3779 copy(dAtA[i:], m.unknownFields) 3780 } 3781 if len(m.TableSchemaChanged) > 0 { 3782 for iNdEx := len(m.TableSchemaChanged) - 1; iNdEx >= 0; iNdEx-- { 3783 i -= len(m.TableSchemaChanged[iNdEx]) 3784 copy(dAtA[i:], m.TableSchemaChanged[iNdEx]) 3785 i = encodeVarint(dAtA, i, uint64(len(m.TableSchemaChanged[iNdEx]))) 3786 i-- 3787 dAtA[i] = 0x3a 3788 } 3789 } 3790 if m.Qps != 0 { 3791 i -= 8 3792 binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Qps)))) 3793 i-- 3794 dAtA[i] = 0x31 3795 } 3796 if m.CpuUsage != 0 { 3797 i -= 8 3798 binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.CpuUsage)))) 3799 i-- 3800 dAtA[i] = 0x29 3801 } 3802 if m.FilteredReplicationLagSeconds != 0 { 3803 i = encodeVarint(dAtA, i, uint64(m.FilteredReplicationLagSeconds)) 3804 i-- 3805 dAtA[i] = 0x20 3806 } 3807 if m.BinlogPlayersCount != 0 { 3808 i = encodeVarint(dAtA, i, uint64(m.BinlogPlayersCount)) 3809 i-- 3810 dAtA[i] = 0x18 3811 } 3812 if m.ReplicationLagSeconds != 0 { 3813 i = encodeVarint(dAtA, i, uint64(m.ReplicationLagSeconds)) 3814 i-- 3815 dAtA[i] = 0x10 3816 } 3817 if len(m.HealthError) > 0 { 3818 i -= len(m.HealthError) 3819 copy(dAtA[i:], m.HealthError) 3820 i = encodeVarint(dAtA, i, uint64(len(m.HealthError))) 3821 i-- 3822 dAtA[i] = 0xa 3823 } 3824 return len(dAtA) - i, nil 3825 } 3826 3827 func (m *AggregateStats) MarshalVT() (dAtA []byte, err error) { 3828 if m == nil { 3829 return nil, nil 3830 } 3831 size := m.SizeVT() 3832 dAtA = make([]byte, size) 3833 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 3834 if err != nil { 3835 return nil, err 3836 } 3837 return dAtA[:n], nil 3838 } 3839 3840 func (m *AggregateStats) MarshalToVT(dAtA []byte) (int, error) { 3841 size := m.SizeVT() 3842 return m.MarshalToSizedBufferVT(dAtA[:size]) 3843 } 3844 3845 func (m *AggregateStats) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 3846 if m == nil { 3847 return 0, nil 3848 } 3849 i := len(dAtA) 3850 _ = i 3851 var l int 3852 _ = l 3853 if m.unknownFields != nil { 3854 i -= len(m.unknownFields) 3855 copy(dAtA[i:], m.unknownFields) 3856 } 3857 if m.ReplicationLagSecondsMax != 0 { 3858 i = encodeVarint(dAtA, i, uint64(m.ReplicationLagSecondsMax)) 3859 i-- 3860 dAtA[i] = 0x20 3861 } 3862 if m.ReplicationLagSecondsMin != 0 { 3863 i = encodeVarint(dAtA, i, uint64(m.ReplicationLagSecondsMin)) 3864 i-- 3865 dAtA[i] = 0x18 3866 } 3867 if m.UnhealthyTabletCount != 0 { 3868 i = encodeVarint(dAtA, i, uint64(m.UnhealthyTabletCount)) 3869 i-- 3870 dAtA[i] = 0x10 3871 } 3872 if m.HealthyTabletCount != 0 { 3873 i = encodeVarint(dAtA, i, uint64(m.HealthyTabletCount)) 3874 i-- 3875 dAtA[i] = 0x8 3876 } 3877 return len(dAtA) - i, nil 3878 } 3879 3880 func (m *StreamHealthResponse) MarshalVT() (dAtA []byte, err error) { 3881 if m == nil { 3882 return nil, nil 3883 } 3884 size := m.SizeVT() 3885 dAtA = make([]byte, size) 3886 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 3887 if err != nil { 3888 return nil, err 3889 } 3890 return dAtA[:n], nil 3891 } 3892 3893 func (m *StreamHealthResponse) MarshalToVT(dAtA []byte) (int, error) { 3894 size := m.SizeVT() 3895 return m.MarshalToSizedBufferVT(dAtA[:size]) 3896 } 3897 3898 func (m *StreamHealthResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 3899 if m == nil { 3900 return 0, nil 3901 } 3902 i := len(dAtA) 3903 _ = i 3904 var l int 3905 _ = l 3906 if m.unknownFields != nil { 3907 i -= len(m.unknownFields) 3908 copy(dAtA[i:], m.unknownFields) 3909 } 3910 if m.TabletAlias != nil { 3911 size, err := m.TabletAlias.MarshalToSizedBufferVT(dAtA[:i]) 3912 if err != nil { 3913 return 0, err 3914 } 3915 i -= size 3916 i = encodeVarint(dAtA, i, uint64(size)) 3917 i-- 3918 dAtA[i] = 0x2a 3919 } 3920 if m.RealtimeStats != nil { 3921 size, err := m.RealtimeStats.MarshalToSizedBufferVT(dAtA[:i]) 3922 if err != nil { 3923 return 0, err 3924 } 3925 i -= size 3926 i = encodeVarint(dAtA, i, uint64(size)) 3927 i-- 3928 dAtA[i] = 0x22 3929 } 3930 if m.TabletExternallyReparentedTimestamp != 0 { 3931 i = encodeVarint(dAtA, i, uint64(m.TabletExternallyReparentedTimestamp)) 3932 i-- 3933 dAtA[i] = 0x18 3934 } 3935 if m.Serving { 3936 i-- 3937 if m.Serving { 3938 dAtA[i] = 1 3939 } else { 3940 dAtA[i] = 0 3941 } 3942 i-- 3943 dAtA[i] = 0x10 3944 } 3945 if m.Target != nil { 3946 size, err := m.Target.MarshalToSizedBufferVT(dAtA[:i]) 3947 if err != nil { 3948 return 0, err 3949 } 3950 i -= size 3951 i = encodeVarint(dAtA, i, uint64(size)) 3952 i-- 3953 dAtA[i] = 0xa 3954 } 3955 return len(dAtA) - i, nil 3956 } 3957 3958 func (m *TransactionMetadata) MarshalVT() (dAtA []byte, err error) { 3959 if m == nil { 3960 return nil, nil 3961 } 3962 size := m.SizeVT() 3963 dAtA = make([]byte, size) 3964 n, err := m.MarshalToSizedBufferVT(dAtA[:size]) 3965 if err != nil { 3966 return nil, err 3967 } 3968 return dAtA[:n], nil 3969 } 3970 3971 func (m *TransactionMetadata) MarshalToVT(dAtA []byte) (int, error) { 3972 size := m.SizeVT() 3973 return m.MarshalToSizedBufferVT(dAtA[:size]) 3974 } 3975 3976 func (m *TransactionMetadata) MarshalToSizedBufferVT(dAtA []byte) (int, error) { 3977 if m == nil { 3978 return 0, nil 3979 } 3980 i := len(dAtA) 3981 _ = i 3982 var l int 3983 _ = l 3984 if m.unknownFields != nil { 3985 i -= len(m.unknownFields) 3986 copy(dAtA[i:], m.unknownFields) 3987 } 3988 if len(m.Participants) > 0 { 3989 for iNdEx := len(m.Participants) - 1; iNdEx >= 0; iNdEx-- { 3990 size, err := m.Participants[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) 3991 if err != nil { 3992 return 0, err 3993 } 3994 i -= size 3995 i = encodeVarint(dAtA, i, uint64(size)) 3996 i-- 3997 dAtA[i] = 0x22 3998 } 3999 } 4000 if m.TimeCreated != 0 { 4001 i = encodeVarint(dAtA, i, uint64(m.TimeCreated)) 4002 i-- 4003 dAtA[i] = 0x18 4004 } 4005 if m.State != 0 { 4006 i = encodeVarint(dAtA, i, uint64(m.State)) 4007 i-- 4008 dAtA[i] = 0x10 4009 } 4010 if len(m.Dtid) > 0 { 4011 i -= len(m.Dtid) 4012 copy(dAtA[i:], m.Dtid) 4013 i = encodeVarint(dAtA, i, uint64(len(m.Dtid))) 4014 i-- 4015 dAtA[i] = 0xa 4016 } 4017 return len(dAtA) - i, nil 4018 } 4019 4020 func encodeVarint(dAtA []byte, offset int, v uint64) int { 4021 offset -= sov(v) 4022 base := offset 4023 for v >= 1<<7 { 4024 dAtA[offset] = uint8(v&0x7f | 0x80) 4025 v >>= 7 4026 offset++ 4027 } 4028 dAtA[offset] = uint8(v) 4029 return base 4030 } 4031 4032 var vtprotoPool_Row = sync.Pool{ 4033 New: func() interface{} { 4034 return &Row{} 4035 }, 4036 } 4037 4038 func (m *Row) ResetVT() { 4039 f0 := m.Lengths[:0] 4040 f1 := m.Values[:0] 4041 m.Reset() 4042 m.Lengths = f0 4043 m.Values = f1 4044 } 4045 func (m *Row) ReturnToVTPool() { 4046 if m != nil { 4047 m.ResetVT() 4048 vtprotoPool_Row.Put(m) 4049 } 4050 } 4051 func RowFromVTPool() *Row { 4052 return vtprotoPool_Row.Get().(*Row) 4053 } 4054 func (m *Target) SizeVT() (n int) { 4055 if m == nil { 4056 return 0 4057 } 4058 var l int 4059 _ = l 4060 l = len(m.Keyspace) 4061 if l > 0 { 4062 n += 1 + l + sov(uint64(l)) 4063 } 4064 l = len(m.Shard) 4065 if l > 0 { 4066 n += 1 + l + sov(uint64(l)) 4067 } 4068 if m.TabletType != 0 { 4069 n += 1 + sov(uint64(m.TabletType)) 4070 } 4071 l = len(m.Cell) 4072 if l > 0 { 4073 n += 1 + l + sov(uint64(l)) 4074 } 4075 if m.unknownFields != nil { 4076 n += len(m.unknownFields) 4077 } 4078 return n 4079 } 4080 4081 func (m *VTGateCallerID) SizeVT() (n int) { 4082 if m == nil { 4083 return 0 4084 } 4085 var l int 4086 _ = l 4087 l = len(m.Username) 4088 if l > 0 { 4089 n += 1 + l + sov(uint64(l)) 4090 } 4091 if len(m.Groups) > 0 { 4092 for _, s := range m.Groups { 4093 l = len(s) 4094 n += 1 + l + sov(uint64(l)) 4095 } 4096 } 4097 if m.unknownFields != nil { 4098 n += len(m.unknownFields) 4099 } 4100 return n 4101 } 4102 4103 func (m *EventToken) SizeVT() (n int) { 4104 if m == nil { 4105 return 0 4106 } 4107 var l int 4108 _ = l 4109 if m.Timestamp != 0 { 4110 n += 1 + sov(uint64(m.Timestamp)) 4111 } 4112 l = len(m.Shard) 4113 if l > 0 { 4114 n += 1 + l + sov(uint64(l)) 4115 } 4116 l = len(m.Position) 4117 if l > 0 { 4118 n += 1 + l + sov(uint64(l)) 4119 } 4120 if m.unknownFields != nil { 4121 n += len(m.unknownFields) 4122 } 4123 return n 4124 } 4125 4126 func (m *Value) SizeVT() (n int) { 4127 if m == nil { 4128 return 0 4129 } 4130 var l int 4131 _ = l 4132 if m.Type != 0 { 4133 n += 1 + sov(uint64(m.Type)) 4134 } 4135 l = len(m.Value) 4136 if l > 0 { 4137 n += 1 + l + sov(uint64(l)) 4138 } 4139 if m.unknownFields != nil { 4140 n += len(m.unknownFields) 4141 } 4142 return n 4143 } 4144 4145 func (m *BindVariable) SizeVT() (n int) { 4146 if m == nil { 4147 return 0 4148 } 4149 var l int 4150 _ = l 4151 if m.Type != 0 { 4152 n += 1 + sov(uint64(m.Type)) 4153 } 4154 l = len(m.Value) 4155 if l > 0 { 4156 n += 1 + l + sov(uint64(l)) 4157 } 4158 if len(m.Values) > 0 { 4159 for _, e := range m.Values { 4160 l = e.SizeVT() 4161 n += 1 + l + sov(uint64(l)) 4162 } 4163 } 4164 if m.unknownFields != nil { 4165 n += len(m.unknownFields) 4166 } 4167 return n 4168 } 4169 4170 func (m *BoundQuery) SizeVT() (n int) { 4171 if m == nil { 4172 return 0 4173 } 4174 var l int 4175 _ = l 4176 l = len(m.Sql) 4177 if l > 0 { 4178 n += 1 + l + sov(uint64(l)) 4179 } 4180 if len(m.BindVariables) > 0 { 4181 for k, v := range m.BindVariables { 4182 _ = k 4183 _ = v 4184 l = 0 4185 if v != nil { 4186 l = v.SizeVT() 4187 } 4188 l += 1 + sov(uint64(l)) 4189 mapEntrySize := 1 + len(k) + sov(uint64(len(k))) + l 4190 n += mapEntrySize + 1 + sov(uint64(mapEntrySize)) 4191 } 4192 } 4193 if m.unknownFields != nil { 4194 n += len(m.unknownFields) 4195 } 4196 return n 4197 } 4198 4199 func (m *ExecuteOptions) SizeVT() (n int) { 4200 if m == nil { 4201 return 0 4202 } 4203 var l int 4204 _ = l 4205 if m.IncludedFields != 0 { 4206 n += 1 + sov(uint64(m.IncludedFields)) 4207 } 4208 if m.ClientFoundRows { 4209 n += 2 4210 } 4211 if m.Workload != 0 { 4212 n += 1 + sov(uint64(m.Workload)) 4213 } 4214 if m.SqlSelectLimit != 0 { 4215 n += 1 + sov(uint64(m.SqlSelectLimit)) 4216 } 4217 if m.TransactionIsolation != 0 { 4218 n += 1 + sov(uint64(m.TransactionIsolation)) 4219 } 4220 if m.SkipQueryPlanCache { 4221 n += 2 4222 } 4223 if m.PlannerVersion != 0 { 4224 n += 1 + sov(uint64(m.PlannerVersion)) 4225 } 4226 if m.HasCreatedTempTables { 4227 n += 2 4228 } 4229 if m.unknownFields != nil { 4230 n += len(m.unknownFields) 4231 } 4232 return n 4233 } 4234 4235 func (m *Field) SizeVT() (n int) { 4236 if m == nil { 4237 return 0 4238 } 4239 var l int 4240 _ = l 4241 l = len(m.Name) 4242 if l > 0 { 4243 n += 1 + l + sov(uint64(l)) 4244 } 4245 if m.Type != 0 { 4246 n += 1 + sov(uint64(m.Type)) 4247 } 4248 l = len(m.Table) 4249 if l > 0 { 4250 n += 1 + l + sov(uint64(l)) 4251 } 4252 l = len(m.OrgTable) 4253 if l > 0 { 4254 n += 1 + l + sov(uint64(l)) 4255 } 4256 l = len(m.Database) 4257 if l > 0 { 4258 n += 1 + l + sov(uint64(l)) 4259 } 4260 l = len(m.OrgName) 4261 if l > 0 { 4262 n += 1 + l + sov(uint64(l)) 4263 } 4264 if m.ColumnLength != 0 { 4265 n += 1 + sov(uint64(m.ColumnLength)) 4266 } 4267 if m.Charset != 0 { 4268 n += 1 + sov(uint64(m.Charset)) 4269 } 4270 if m.Decimals != 0 { 4271 n += 1 + sov(uint64(m.Decimals)) 4272 } 4273 if m.Flags != 0 { 4274 n += 1 + sov(uint64(m.Flags)) 4275 } 4276 l = len(m.ColumnType) 4277 if l > 0 { 4278 n += 1 + l + sov(uint64(l)) 4279 } 4280 if m.unknownFields != nil { 4281 n += len(m.unknownFields) 4282 } 4283 return n 4284 } 4285 4286 func (m *Row) SizeVT() (n int) { 4287 if m == nil { 4288 return 0 4289 } 4290 var l int 4291 _ = l 4292 if len(m.Lengths) > 0 { 4293 l = 0 4294 for _, e := range m.Lengths { 4295 l += soz(uint64(e)) 4296 } 4297 n += 1 + sov(uint64(l)) + l 4298 } 4299 l = len(m.Values) 4300 if l > 0 { 4301 n += 1 + l + sov(uint64(l)) 4302 } 4303 if m.unknownFields != nil { 4304 n += len(m.unknownFields) 4305 } 4306 return n 4307 } 4308 4309 func (m *QueryResult) SizeVT() (n int) { 4310 if m == nil { 4311 return 0 4312 } 4313 var l int 4314 _ = l 4315 if len(m.Fields) > 0 { 4316 for _, e := range m.Fields { 4317 l = e.SizeVT() 4318 n += 1 + l + sov(uint64(l)) 4319 } 4320 } 4321 if m.RowsAffected != 0 { 4322 n += 1 + sov(uint64(m.RowsAffected)) 4323 } 4324 if m.InsertId != 0 { 4325 n += 1 + sov(uint64(m.InsertId)) 4326 } 4327 if len(m.Rows) > 0 { 4328 for _, e := range m.Rows { 4329 l = e.SizeVT() 4330 n += 1 + l + sov(uint64(l)) 4331 } 4332 } 4333 if m.unknownFields != nil { 4334 n += len(m.unknownFields) 4335 } 4336 return n 4337 } 4338 4339 func (m *QueryWarning) SizeVT() (n int) { 4340 if m == nil { 4341 return 0 4342 } 4343 var l int 4344 _ = l 4345 if m.Code != 0 { 4346 n += 1 + sov(uint64(m.Code)) 4347 } 4348 l = len(m.Message) 4349 if l > 0 { 4350 n += 1 + l + sov(uint64(l)) 4351 } 4352 if m.unknownFields != nil { 4353 n += len(m.unknownFields) 4354 } 4355 return n 4356 } 4357 4358 func (m *StreamEvent_Statement) SizeVT() (n int) { 4359 if m == nil { 4360 return 0 4361 } 4362 var l int 4363 _ = l 4364 if m.Category != 0 { 4365 n += 1 + sov(uint64(m.Category)) 4366 } 4367 l = len(m.TableName) 4368 if l > 0 { 4369 n += 1 + l + sov(uint64(l)) 4370 } 4371 if len(m.PrimaryKeyFields) > 0 { 4372 for _, e := range m.PrimaryKeyFields { 4373 l = e.SizeVT() 4374 n += 1 + l + sov(uint64(l)) 4375 } 4376 } 4377 if len(m.PrimaryKeyValues) > 0 { 4378 for _, e := range m.PrimaryKeyValues { 4379 l = e.SizeVT() 4380 n += 1 + l + sov(uint64(l)) 4381 } 4382 } 4383 l = len(m.Sql) 4384 if l > 0 { 4385 n += 1 + l + sov(uint64(l)) 4386 } 4387 if m.unknownFields != nil { 4388 n += len(m.unknownFields) 4389 } 4390 return n 4391 } 4392 4393 func (m *StreamEvent) SizeVT() (n int) { 4394 if m == nil { 4395 return 0 4396 } 4397 var l int 4398 _ = l 4399 if len(m.Statements) > 0 { 4400 for _, e := range m.Statements { 4401 l = e.SizeVT() 4402 n += 1 + l + sov(uint64(l)) 4403 } 4404 } 4405 if m.EventToken != nil { 4406 l = m.EventToken.SizeVT() 4407 n += 1 + l + sov(uint64(l)) 4408 } 4409 if m.unknownFields != nil { 4410 n += len(m.unknownFields) 4411 } 4412 return n 4413 } 4414 4415 func (m *ExecuteRequest) SizeVT() (n int) { 4416 if m == nil { 4417 return 0 4418 } 4419 var l int 4420 _ = l 4421 if m.EffectiveCallerId != nil { 4422 l = m.EffectiveCallerId.SizeVT() 4423 n += 1 + l + sov(uint64(l)) 4424 } 4425 if m.ImmediateCallerId != nil { 4426 l = m.ImmediateCallerId.SizeVT() 4427 n += 1 + l + sov(uint64(l)) 4428 } 4429 if m.Target != nil { 4430 l = m.Target.SizeVT() 4431 n += 1 + l + sov(uint64(l)) 4432 } 4433 if m.Query != nil { 4434 l = m.Query.SizeVT() 4435 n += 1 + l + sov(uint64(l)) 4436 } 4437 if m.TransactionId != 0 { 4438 n += 1 + sov(uint64(m.TransactionId)) 4439 } 4440 if m.Options != nil { 4441 l = m.Options.SizeVT() 4442 n += 1 + l + sov(uint64(l)) 4443 } 4444 if m.ReservedId != 0 { 4445 n += 1 + sov(uint64(m.ReservedId)) 4446 } 4447 if m.unknownFields != nil { 4448 n += len(m.unknownFields) 4449 } 4450 return n 4451 } 4452 4453 func (m *ExecuteResponse) SizeVT() (n int) { 4454 if m == nil { 4455 return 0 4456 } 4457 var l int 4458 _ = l 4459 if m.Result != nil { 4460 l = m.Result.SizeVT() 4461 n += 1 + l + sov(uint64(l)) 4462 } 4463 if m.unknownFields != nil { 4464 n += len(m.unknownFields) 4465 } 4466 return n 4467 } 4468 4469 func (m *ResultWithError) SizeVT() (n int) { 4470 if m == nil { 4471 return 0 4472 } 4473 var l int 4474 _ = l 4475 if m.Error != nil { 4476 l = m.Error.SizeVT() 4477 n += 1 + l + sov(uint64(l)) 4478 } 4479 if m.Result != nil { 4480 l = m.Result.SizeVT() 4481 n += 1 + l + sov(uint64(l)) 4482 } 4483 if m.unknownFields != nil { 4484 n += len(m.unknownFields) 4485 } 4486 return n 4487 } 4488 4489 func (m *StreamExecuteRequest) SizeVT() (n int) { 4490 if m == nil { 4491 return 0 4492 } 4493 var l int 4494 _ = l 4495 if m.EffectiveCallerId != nil { 4496 l = m.EffectiveCallerId.SizeVT() 4497 n += 1 + l + sov(uint64(l)) 4498 } 4499 if m.ImmediateCallerId != nil { 4500 l = m.ImmediateCallerId.SizeVT() 4501 n += 1 + l + sov(uint64(l)) 4502 } 4503 if m.Target != nil { 4504 l = m.Target.SizeVT() 4505 n += 1 + l + sov(uint64(l)) 4506 } 4507 if m.Query != nil { 4508 l = m.Query.SizeVT() 4509 n += 1 + l + sov(uint64(l)) 4510 } 4511 if m.Options != nil { 4512 l = m.Options.SizeVT() 4513 n += 1 + l + sov(uint64(l)) 4514 } 4515 if m.TransactionId != 0 { 4516 n += 1 + sov(uint64(m.TransactionId)) 4517 } 4518 if m.ReservedId != 0 { 4519 n += 1 + sov(uint64(m.ReservedId)) 4520 } 4521 if m.unknownFields != nil { 4522 n += len(m.unknownFields) 4523 } 4524 return n 4525 } 4526 4527 func (m *StreamExecuteResponse) SizeVT() (n int) { 4528 if m == nil { 4529 return 0 4530 } 4531 var l int 4532 _ = l 4533 if m.Result != nil { 4534 l = m.Result.SizeVT() 4535 n += 1 + l + sov(uint64(l)) 4536 } 4537 if m.unknownFields != nil { 4538 n += len(m.unknownFields) 4539 } 4540 return n 4541 } 4542 4543 func (m *BeginRequest) SizeVT() (n int) { 4544 if m == nil { 4545 return 0 4546 } 4547 var l int 4548 _ = l 4549 if m.EffectiveCallerId != nil { 4550 l = m.EffectiveCallerId.SizeVT() 4551 n += 1 + l + sov(uint64(l)) 4552 } 4553 if m.ImmediateCallerId != nil { 4554 l = m.ImmediateCallerId.SizeVT() 4555 n += 1 + l + sov(uint64(l)) 4556 } 4557 if m.Target != nil { 4558 l = m.Target.SizeVT() 4559 n += 1 + l + sov(uint64(l)) 4560 } 4561 if m.Options != nil { 4562 l = m.Options.SizeVT() 4563 n += 1 + l + sov(uint64(l)) 4564 } 4565 if m.unknownFields != nil { 4566 n += len(m.unknownFields) 4567 } 4568 return n 4569 } 4570 4571 func (m *BeginResponse) SizeVT() (n int) { 4572 if m == nil { 4573 return 0 4574 } 4575 var l int 4576 _ = l 4577 if m.TransactionId != 0 { 4578 n += 1 + sov(uint64(m.TransactionId)) 4579 } 4580 if m.TabletAlias != nil { 4581 l = m.TabletAlias.SizeVT() 4582 n += 1 + l + sov(uint64(l)) 4583 } 4584 if m.unknownFields != nil { 4585 n += len(m.unknownFields) 4586 } 4587 return n 4588 } 4589 4590 func (m *CommitRequest) SizeVT() (n int) { 4591 if m == nil { 4592 return 0 4593 } 4594 var l int 4595 _ = l 4596 if m.EffectiveCallerId != nil { 4597 l = m.EffectiveCallerId.SizeVT() 4598 n += 1 + l + sov(uint64(l)) 4599 } 4600 if m.ImmediateCallerId != nil { 4601 l = m.ImmediateCallerId.SizeVT() 4602 n += 1 + l + sov(uint64(l)) 4603 } 4604 if m.Target != nil { 4605 l = m.Target.SizeVT() 4606 n += 1 + l + sov(uint64(l)) 4607 } 4608 if m.TransactionId != 0 { 4609 n += 1 + sov(uint64(m.TransactionId)) 4610 } 4611 if m.unknownFields != nil { 4612 n += len(m.unknownFields) 4613 } 4614 return n 4615 } 4616 4617 func (m *CommitResponse) SizeVT() (n int) { 4618 if m == nil { 4619 return 0 4620 } 4621 var l int 4622 _ = l 4623 if m.ReservedId != 0 { 4624 n += 1 + sov(uint64(m.ReservedId)) 4625 } 4626 if m.unknownFields != nil { 4627 n += len(m.unknownFields) 4628 } 4629 return n 4630 } 4631 4632 func (m *RollbackRequest) SizeVT() (n int) { 4633 if m == nil { 4634 return 0 4635 } 4636 var l int 4637 _ = l 4638 if m.EffectiveCallerId != nil { 4639 l = m.EffectiveCallerId.SizeVT() 4640 n += 1 + l + sov(uint64(l)) 4641 } 4642 if m.ImmediateCallerId != nil { 4643 l = m.ImmediateCallerId.SizeVT() 4644 n += 1 + l + sov(uint64(l)) 4645 } 4646 if m.Target != nil { 4647 l = m.Target.SizeVT() 4648 n += 1 + l + sov(uint64(l)) 4649 } 4650 if m.TransactionId != 0 { 4651 n += 1 + sov(uint64(m.TransactionId)) 4652 } 4653 if m.unknownFields != nil { 4654 n += len(m.unknownFields) 4655 } 4656 return n 4657 } 4658 4659 func (m *RollbackResponse) SizeVT() (n int) { 4660 if m == nil { 4661 return 0 4662 } 4663 var l int 4664 _ = l 4665 if m.ReservedId != 0 { 4666 n += 1 + sov(uint64(m.ReservedId)) 4667 } 4668 if m.unknownFields != nil { 4669 n += len(m.unknownFields) 4670 } 4671 return n 4672 } 4673 4674 func (m *PrepareRequest) SizeVT() (n int) { 4675 if m == nil { 4676 return 0 4677 } 4678 var l int 4679 _ = l 4680 if m.EffectiveCallerId != nil { 4681 l = m.EffectiveCallerId.SizeVT() 4682 n += 1 + l + sov(uint64(l)) 4683 } 4684 if m.ImmediateCallerId != nil { 4685 l = m.ImmediateCallerId.SizeVT() 4686 n += 1 + l + sov(uint64(l)) 4687 } 4688 if m.Target != nil { 4689 l = m.Target.SizeVT() 4690 n += 1 + l + sov(uint64(l)) 4691 } 4692 if m.TransactionId != 0 { 4693 n += 1 + sov(uint64(m.TransactionId)) 4694 } 4695 l = len(m.Dtid) 4696 if l > 0 { 4697 n += 1 + l + sov(uint64(l)) 4698 } 4699 if m.unknownFields != nil { 4700 n += len(m.unknownFields) 4701 } 4702 return n 4703 } 4704 4705 func (m *PrepareResponse) SizeVT() (n int) { 4706 if m == nil { 4707 return 0 4708 } 4709 var l int 4710 _ = l 4711 if m.unknownFields != nil { 4712 n += len(m.unknownFields) 4713 } 4714 return n 4715 } 4716 4717 func (m *CommitPreparedRequest) SizeVT() (n int) { 4718 if m == nil { 4719 return 0 4720 } 4721 var l int 4722 _ = l 4723 if m.EffectiveCallerId != nil { 4724 l = m.EffectiveCallerId.SizeVT() 4725 n += 1 + l + sov(uint64(l)) 4726 } 4727 if m.ImmediateCallerId != nil { 4728 l = m.ImmediateCallerId.SizeVT() 4729 n += 1 + l + sov(uint64(l)) 4730 } 4731 if m.Target != nil { 4732 l = m.Target.SizeVT() 4733 n += 1 + l + sov(uint64(l)) 4734 } 4735 l = len(m.Dtid) 4736 if l > 0 { 4737 n += 1 + l + sov(uint64(l)) 4738 } 4739 if m.unknownFields != nil { 4740 n += len(m.unknownFields) 4741 } 4742 return n 4743 } 4744 4745 func (m *CommitPreparedResponse) SizeVT() (n int) { 4746 if m == nil { 4747 return 0 4748 } 4749 var l int 4750 _ = l 4751 if m.unknownFields != nil { 4752 n += len(m.unknownFields) 4753 } 4754 return n 4755 } 4756 4757 func (m *RollbackPreparedRequest) SizeVT() (n int) { 4758 if m == nil { 4759 return 0 4760 } 4761 var l int 4762 _ = l 4763 if m.EffectiveCallerId != nil { 4764 l = m.EffectiveCallerId.SizeVT() 4765 n += 1 + l + sov(uint64(l)) 4766 } 4767 if m.ImmediateCallerId != nil { 4768 l = m.ImmediateCallerId.SizeVT() 4769 n += 1 + l + sov(uint64(l)) 4770 } 4771 if m.Target != nil { 4772 l = m.Target.SizeVT() 4773 n += 1 + l + sov(uint64(l)) 4774 } 4775 if m.TransactionId != 0 { 4776 n += 1 + sov(uint64(m.TransactionId)) 4777 } 4778 l = len(m.Dtid) 4779 if l > 0 { 4780 n += 1 + l + sov(uint64(l)) 4781 } 4782 if m.unknownFields != nil { 4783 n += len(m.unknownFields) 4784 } 4785 return n 4786 } 4787 4788 func (m *RollbackPreparedResponse) SizeVT() (n int) { 4789 if m == nil { 4790 return 0 4791 } 4792 var l int 4793 _ = l 4794 if m.unknownFields != nil { 4795 n += len(m.unknownFields) 4796 } 4797 return n 4798 } 4799 4800 func (m *CreateTransactionRequest) SizeVT() (n int) { 4801 if m == nil { 4802 return 0 4803 } 4804 var l int 4805 _ = l 4806 if m.EffectiveCallerId != nil { 4807 l = m.EffectiveCallerId.SizeVT() 4808 n += 1 + l + sov(uint64(l)) 4809 } 4810 if m.ImmediateCallerId != nil { 4811 l = m.ImmediateCallerId.SizeVT() 4812 n += 1 + l + sov(uint64(l)) 4813 } 4814 if m.Target != nil { 4815 l = m.Target.SizeVT() 4816 n += 1 + l + sov(uint64(l)) 4817 } 4818 l = len(m.Dtid) 4819 if l > 0 { 4820 n += 1 + l + sov(uint64(l)) 4821 } 4822 if len(m.Participants) > 0 { 4823 for _, e := range m.Participants { 4824 l = e.SizeVT() 4825 n += 1 + l + sov(uint64(l)) 4826 } 4827 } 4828 if m.unknownFields != nil { 4829 n += len(m.unknownFields) 4830 } 4831 return n 4832 } 4833 4834 func (m *CreateTransactionResponse) SizeVT() (n int) { 4835 if m == nil { 4836 return 0 4837 } 4838 var l int 4839 _ = l 4840 if m.unknownFields != nil { 4841 n += len(m.unknownFields) 4842 } 4843 return n 4844 } 4845 4846 func (m *StartCommitRequest) SizeVT() (n int) { 4847 if m == nil { 4848 return 0 4849 } 4850 var l int 4851 _ = l 4852 if m.EffectiveCallerId != nil { 4853 l = m.EffectiveCallerId.SizeVT() 4854 n += 1 + l + sov(uint64(l)) 4855 } 4856 if m.ImmediateCallerId != nil { 4857 l = m.ImmediateCallerId.SizeVT() 4858 n += 1 + l + sov(uint64(l)) 4859 } 4860 if m.Target != nil { 4861 l = m.Target.SizeVT() 4862 n += 1 + l + sov(uint64(l)) 4863 } 4864 if m.TransactionId != 0 { 4865 n += 1 + sov(uint64(m.TransactionId)) 4866 } 4867 l = len(m.Dtid) 4868 if l > 0 { 4869 n += 1 + l + sov(uint64(l)) 4870 } 4871 if m.unknownFields != nil { 4872 n += len(m.unknownFields) 4873 } 4874 return n 4875 } 4876 4877 func (m *StartCommitResponse) SizeVT() (n int) { 4878 if m == nil { 4879 return 0 4880 } 4881 var l int 4882 _ = l 4883 if m.unknownFields != nil { 4884 n += len(m.unknownFields) 4885 } 4886 return n 4887 } 4888 4889 func (m *SetRollbackRequest) SizeVT() (n int) { 4890 if m == nil { 4891 return 0 4892 } 4893 var l int 4894 _ = l 4895 if m.EffectiveCallerId != nil { 4896 l = m.EffectiveCallerId.SizeVT() 4897 n += 1 + l + sov(uint64(l)) 4898 } 4899 if m.ImmediateCallerId != nil { 4900 l = m.ImmediateCallerId.SizeVT() 4901 n += 1 + l + sov(uint64(l)) 4902 } 4903 if m.Target != nil { 4904 l = m.Target.SizeVT() 4905 n += 1 + l + sov(uint64(l)) 4906 } 4907 if m.TransactionId != 0 { 4908 n += 1 + sov(uint64(m.TransactionId)) 4909 } 4910 l = len(m.Dtid) 4911 if l > 0 { 4912 n += 1 + l + sov(uint64(l)) 4913 } 4914 if m.unknownFields != nil { 4915 n += len(m.unknownFields) 4916 } 4917 return n 4918 } 4919 4920 func (m *SetRollbackResponse) SizeVT() (n int) { 4921 if m == nil { 4922 return 0 4923 } 4924 var l int 4925 _ = l 4926 if m.unknownFields != nil { 4927 n += len(m.unknownFields) 4928 } 4929 return n 4930 } 4931 4932 func (m *ConcludeTransactionRequest) SizeVT() (n int) { 4933 if m == nil { 4934 return 0 4935 } 4936 var l int 4937 _ = l 4938 if m.EffectiveCallerId != nil { 4939 l = m.EffectiveCallerId.SizeVT() 4940 n += 1 + l + sov(uint64(l)) 4941 } 4942 if m.ImmediateCallerId != nil { 4943 l = m.ImmediateCallerId.SizeVT() 4944 n += 1 + l + sov(uint64(l)) 4945 } 4946 if m.Target != nil { 4947 l = m.Target.SizeVT() 4948 n += 1 + l + sov(uint64(l)) 4949 } 4950 l = len(m.Dtid) 4951 if l > 0 { 4952 n += 1 + l + sov(uint64(l)) 4953 } 4954 if m.unknownFields != nil { 4955 n += len(m.unknownFields) 4956 } 4957 return n 4958 } 4959 4960 func (m *ConcludeTransactionResponse) SizeVT() (n int) { 4961 if m == nil { 4962 return 0 4963 } 4964 var l int 4965 _ = l 4966 if m.unknownFields != nil { 4967 n += len(m.unknownFields) 4968 } 4969 return n 4970 } 4971 4972 func (m *ReadTransactionRequest) SizeVT() (n int) { 4973 if m == nil { 4974 return 0 4975 } 4976 var l int 4977 _ = l 4978 if m.EffectiveCallerId != nil { 4979 l = m.EffectiveCallerId.SizeVT() 4980 n += 1 + l + sov(uint64(l)) 4981 } 4982 if m.ImmediateCallerId != nil { 4983 l = m.ImmediateCallerId.SizeVT() 4984 n += 1 + l + sov(uint64(l)) 4985 } 4986 if m.Target != nil { 4987 l = m.Target.SizeVT() 4988 n += 1 + l + sov(uint64(l)) 4989 } 4990 l = len(m.Dtid) 4991 if l > 0 { 4992 n += 1 + l + sov(uint64(l)) 4993 } 4994 if m.unknownFields != nil { 4995 n += len(m.unknownFields) 4996 } 4997 return n 4998 } 4999 5000 func (m *ReadTransactionResponse) SizeVT() (n int) { 5001 if m == nil { 5002 return 0 5003 } 5004 var l int 5005 _ = l 5006 if m.Metadata != nil { 5007 l = m.Metadata.SizeVT() 5008 n += 1 + l + sov(uint64(l)) 5009 } 5010 if m.unknownFields != nil { 5011 n += len(m.unknownFields) 5012 } 5013 return n 5014 } 5015 5016 func (m *BeginExecuteRequest) SizeVT() (n int) { 5017 if m == nil { 5018 return 0 5019 } 5020 var l int 5021 _ = l 5022 if m.EffectiveCallerId != nil { 5023 l = m.EffectiveCallerId.SizeVT() 5024 n += 1 + l + sov(uint64(l)) 5025 } 5026 if m.ImmediateCallerId != nil { 5027 l = m.ImmediateCallerId.SizeVT() 5028 n += 1 + l + sov(uint64(l)) 5029 } 5030 if m.Target != nil { 5031 l = m.Target.SizeVT() 5032 n += 1 + l + sov(uint64(l)) 5033 } 5034 if m.Query != nil { 5035 l = m.Query.SizeVT() 5036 n += 1 + l + sov(uint64(l)) 5037 } 5038 if m.Options != nil { 5039 l = m.Options.SizeVT() 5040 n += 1 + l + sov(uint64(l)) 5041 } 5042 if m.ReservedId != 0 { 5043 n += 1 + sov(uint64(m.ReservedId)) 5044 } 5045 if len(m.PreQueries) > 0 { 5046 for _, s := range m.PreQueries { 5047 l = len(s) 5048 n += 1 + l + sov(uint64(l)) 5049 } 5050 } 5051 if m.unknownFields != nil { 5052 n += len(m.unknownFields) 5053 } 5054 return n 5055 } 5056 5057 func (m *BeginExecuteResponse) SizeVT() (n int) { 5058 if m == nil { 5059 return 0 5060 } 5061 var l int 5062 _ = l 5063 if m.Error != nil { 5064 l = m.Error.SizeVT() 5065 n += 1 + l + sov(uint64(l)) 5066 } 5067 if m.Result != nil { 5068 l = m.Result.SizeVT() 5069 n += 1 + l + sov(uint64(l)) 5070 } 5071 if m.TransactionId != 0 { 5072 n += 1 + sov(uint64(m.TransactionId)) 5073 } 5074 if m.TabletAlias != nil { 5075 l = m.TabletAlias.SizeVT() 5076 n += 1 + l + sov(uint64(l)) 5077 } 5078 if m.unknownFields != nil { 5079 n += len(m.unknownFields) 5080 } 5081 return n 5082 } 5083 5084 func (m *BeginStreamExecuteRequest) SizeVT() (n int) { 5085 if m == nil { 5086 return 0 5087 } 5088 var l int 5089 _ = l 5090 if m.EffectiveCallerId != nil { 5091 l = m.EffectiveCallerId.SizeVT() 5092 n += 1 + l + sov(uint64(l)) 5093 } 5094 if m.ImmediateCallerId != nil { 5095 l = m.ImmediateCallerId.SizeVT() 5096 n += 1 + l + sov(uint64(l)) 5097 } 5098 if m.Target != nil { 5099 l = m.Target.SizeVT() 5100 n += 1 + l + sov(uint64(l)) 5101 } 5102 if m.Query != nil { 5103 l = m.Query.SizeVT() 5104 n += 1 + l + sov(uint64(l)) 5105 } 5106 if m.Options != nil { 5107 l = m.Options.SizeVT() 5108 n += 1 + l + sov(uint64(l)) 5109 } 5110 if len(m.PreQueries) > 0 { 5111 for _, s := range m.PreQueries { 5112 l = len(s) 5113 n += 1 + l + sov(uint64(l)) 5114 } 5115 } 5116 if m.ReservedId != 0 { 5117 n += 1 + sov(uint64(m.ReservedId)) 5118 } 5119 if m.unknownFields != nil { 5120 n += len(m.unknownFields) 5121 } 5122 return n 5123 } 5124 5125 func (m *BeginStreamExecuteResponse) SizeVT() (n int) { 5126 if m == nil { 5127 return 0 5128 } 5129 var l int 5130 _ = l 5131 if m.Error != nil { 5132 l = m.Error.SizeVT() 5133 n += 1 + l + sov(uint64(l)) 5134 } 5135 if m.Result != nil { 5136 l = m.Result.SizeVT() 5137 n += 1 + l + sov(uint64(l)) 5138 } 5139 if m.TransactionId != 0 { 5140 n += 1 + sov(uint64(m.TransactionId)) 5141 } 5142 if m.TabletAlias != nil { 5143 l = m.TabletAlias.SizeVT() 5144 n += 1 + l + sov(uint64(l)) 5145 } 5146 if m.unknownFields != nil { 5147 n += len(m.unknownFields) 5148 } 5149 return n 5150 } 5151 5152 func (m *MessageStreamRequest) SizeVT() (n int) { 5153 if m == nil { 5154 return 0 5155 } 5156 var l int 5157 _ = l 5158 if m.EffectiveCallerId != nil { 5159 l = m.EffectiveCallerId.SizeVT() 5160 n += 1 + l + sov(uint64(l)) 5161 } 5162 if m.ImmediateCallerId != nil { 5163 l = m.ImmediateCallerId.SizeVT() 5164 n += 1 + l + sov(uint64(l)) 5165 } 5166 if m.Target != nil { 5167 l = m.Target.SizeVT() 5168 n += 1 + l + sov(uint64(l)) 5169 } 5170 l = len(m.Name) 5171 if l > 0 { 5172 n += 1 + l + sov(uint64(l)) 5173 } 5174 if m.unknownFields != nil { 5175 n += len(m.unknownFields) 5176 } 5177 return n 5178 } 5179 5180 func (m *MessageStreamResponse) SizeVT() (n int) { 5181 if m == nil { 5182 return 0 5183 } 5184 var l int 5185 _ = l 5186 if m.Result != nil { 5187 l = m.Result.SizeVT() 5188 n += 1 + l + sov(uint64(l)) 5189 } 5190 if m.unknownFields != nil { 5191 n += len(m.unknownFields) 5192 } 5193 return n 5194 } 5195 5196 func (m *MessageAckRequest) SizeVT() (n int) { 5197 if m == nil { 5198 return 0 5199 } 5200 var l int 5201 _ = l 5202 if m.EffectiveCallerId != nil { 5203 l = m.EffectiveCallerId.SizeVT() 5204 n += 1 + l + sov(uint64(l)) 5205 } 5206 if m.ImmediateCallerId != nil { 5207 l = m.ImmediateCallerId.SizeVT() 5208 n += 1 + l + sov(uint64(l)) 5209 } 5210 if m.Target != nil { 5211 l = m.Target.SizeVT() 5212 n += 1 + l + sov(uint64(l)) 5213 } 5214 l = len(m.Name) 5215 if l > 0 { 5216 n += 1 + l + sov(uint64(l)) 5217 } 5218 if len(m.Ids) > 0 { 5219 for _, e := range m.Ids { 5220 l = e.SizeVT() 5221 n += 1 + l + sov(uint64(l)) 5222 } 5223 } 5224 if m.unknownFields != nil { 5225 n += len(m.unknownFields) 5226 } 5227 return n 5228 } 5229 5230 func (m *MessageAckResponse) SizeVT() (n int) { 5231 if m == nil { 5232 return 0 5233 } 5234 var l int 5235 _ = l 5236 if m.Result != nil { 5237 l = m.Result.SizeVT() 5238 n += 1 + l + sov(uint64(l)) 5239 } 5240 if m.unknownFields != nil { 5241 n += len(m.unknownFields) 5242 } 5243 return n 5244 } 5245 5246 func (m *ReserveExecuteRequest) SizeVT() (n int) { 5247 if m == nil { 5248 return 0 5249 } 5250 var l int 5251 _ = l 5252 if m.EffectiveCallerId != nil { 5253 l = m.EffectiveCallerId.SizeVT() 5254 n += 1 + l + sov(uint64(l)) 5255 } 5256 if m.ImmediateCallerId != nil { 5257 l = m.ImmediateCallerId.SizeVT() 5258 n += 1 + l + sov(uint64(l)) 5259 } 5260 if m.Target != nil { 5261 l = m.Target.SizeVT() 5262 n += 1 + l + sov(uint64(l)) 5263 } 5264 if m.Query != nil { 5265 l = m.Query.SizeVT() 5266 n += 1 + l + sov(uint64(l)) 5267 } 5268 if m.TransactionId != 0 { 5269 n += 1 + sov(uint64(m.TransactionId)) 5270 } 5271 if m.Options != nil { 5272 l = m.Options.SizeVT() 5273 n += 1 + l + sov(uint64(l)) 5274 } 5275 if len(m.PreQueries) > 0 { 5276 for _, s := range m.PreQueries { 5277 l = len(s) 5278 n += 1 + l + sov(uint64(l)) 5279 } 5280 } 5281 if m.unknownFields != nil { 5282 n += len(m.unknownFields) 5283 } 5284 return n 5285 } 5286 5287 func (m *ReserveExecuteResponse) SizeVT() (n int) { 5288 if m == nil { 5289 return 0 5290 } 5291 var l int 5292 _ = l 5293 if m.Error != nil { 5294 l = m.Error.SizeVT() 5295 n += 1 + l + sov(uint64(l)) 5296 } 5297 if m.Result != nil { 5298 l = m.Result.SizeVT() 5299 n += 1 + l + sov(uint64(l)) 5300 } 5301 if m.ReservedId != 0 { 5302 n += 1 + sov(uint64(m.ReservedId)) 5303 } 5304 if m.TabletAlias != nil { 5305 l = m.TabletAlias.SizeVT() 5306 n += 1 + l + sov(uint64(l)) 5307 } 5308 if m.unknownFields != nil { 5309 n += len(m.unknownFields) 5310 } 5311 return n 5312 } 5313 5314 func (m *ReserveStreamExecuteRequest) SizeVT() (n int) { 5315 if m == nil { 5316 return 0 5317 } 5318 var l int 5319 _ = l 5320 if m.EffectiveCallerId != nil { 5321 l = m.EffectiveCallerId.SizeVT() 5322 n += 1 + l + sov(uint64(l)) 5323 } 5324 if m.ImmediateCallerId != nil { 5325 l = m.ImmediateCallerId.SizeVT() 5326 n += 1 + l + sov(uint64(l)) 5327 } 5328 if m.Target != nil { 5329 l = m.Target.SizeVT() 5330 n += 1 + l + sov(uint64(l)) 5331 } 5332 if m.Query != nil { 5333 l = m.Query.SizeVT() 5334 n += 1 + l + sov(uint64(l)) 5335 } 5336 if m.Options != nil { 5337 l = m.Options.SizeVT() 5338 n += 1 + l + sov(uint64(l)) 5339 } 5340 if m.TransactionId != 0 { 5341 n += 1 + sov(uint64(m.TransactionId)) 5342 } 5343 if len(m.PreQueries) > 0 { 5344 for _, s := range m.PreQueries { 5345 l = len(s) 5346 n += 1 + l + sov(uint64(l)) 5347 } 5348 } 5349 if m.unknownFields != nil { 5350 n += len(m.unknownFields) 5351 } 5352 return n 5353 } 5354 5355 func (m *ReserveStreamExecuteResponse) SizeVT() (n int) { 5356 if m == nil { 5357 return 0 5358 } 5359 var l int 5360 _ = l 5361 if m.Error != nil { 5362 l = m.Error.SizeVT() 5363 n += 1 + l + sov(uint64(l)) 5364 } 5365 if m.Result != nil { 5366 l = m.Result.SizeVT() 5367 n += 1 + l + sov(uint64(l)) 5368 } 5369 if m.ReservedId != 0 { 5370 n += 1 + sov(uint64(m.ReservedId)) 5371 } 5372 if m.TabletAlias != nil { 5373 l = m.TabletAlias.SizeVT() 5374 n += 1 + l + sov(uint64(l)) 5375 } 5376 if m.unknownFields != nil { 5377 n += len(m.unknownFields) 5378 } 5379 return n 5380 } 5381 5382 func (m *ReserveBeginExecuteRequest) SizeVT() (n int) { 5383 if m == nil { 5384 return 0 5385 } 5386 var l int 5387 _ = l 5388 if m.EffectiveCallerId != nil { 5389 l = m.EffectiveCallerId.SizeVT() 5390 n += 1 + l + sov(uint64(l)) 5391 } 5392 if m.ImmediateCallerId != nil { 5393 l = m.ImmediateCallerId.SizeVT() 5394 n += 1 + l + sov(uint64(l)) 5395 } 5396 if m.Target != nil { 5397 l = m.Target.SizeVT() 5398 n += 1 + l + sov(uint64(l)) 5399 } 5400 if m.Query != nil { 5401 l = m.Query.SizeVT() 5402 n += 1 + l + sov(uint64(l)) 5403 } 5404 if m.Options != nil { 5405 l = m.Options.SizeVT() 5406 n += 1 + l + sov(uint64(l)) 5407 } 5408 if len(m.PreQueries) > 0 { 5409 for _, s := range m.PreQueries { 5410 l = len(s) 5411 n += 1 + l + sov(uint64(l)) 5412 } 5413 } 5414 if len(m.PostBeginQueries) > 0 { 5415 for _, s := range m.PostBeginQueries { 5416 l = len(s) 5417 n += 1 + l + sov(uint64(l)) 5418 } 5419 } 5420 if m.unknownFields != nil { 5421 n += len(m.unknownFields) 5422 } 5423 return n 5424 } 5425 5426 func (m *ReserveBeginExecuteResponse) SizeVT() (n int) { 5427 if m == nil { 5428 return 0 5429 } 5430 var l int 5431 _ = l 5432 if m.Error != nil { 5433 l = m.Error.SizeVT() 5434 n += 1 + l + sov(uint64(l)) 5435 } 5436 if m.Result != nil { 5437 l = m.Result.SizeVT() 5438 n += 1 + l + sov(uint64(l)) 5439 } 5440 if m.TransactionId != 0 { 5441 n += 1 + sov(uint64(m.TransactionId)) 5442 } 5443 if m.ReservedId != 0 { 5444 n += 1 + sov(uint64(m.ReservedId)) 5445 } 5446 if m.TabletAlias != nil { 5447 l = m.TabletAlias.SizeVT() 5448 n += 1 + l + sov(uint64(l)) 5449 } 5450 if m.unknownFields != nil { 5451 n += len(m.unknownFields) 5452 } 5453 return n 5454 } 5455 5456 func (m *ReserveBeginStreamExecuteRequest) SizeVT() (n int) { 5457 if m == nil { 5458 return 0 5459 } 5460 var l int 5461 _ = l 5462 if m.EffectiveCallerId != nil { 5463 l = m.EffectiveCallerId.SizeVT() 5464 n += 1 + l + sov(uint64(l)) 5465 } 5466 if m.ImmediateCallerId != nil { 5467 l = m.ImmediateCallerId.SizeVT() 5468 n += 1 + l + sov(uint64(l)) 5469 } 5470 if m.Target != nil { 5471 l = m.Target.SizeVT() 5472 n += 1 + l + sov(uint64(l)) 5473 } 5474 if m.Query != nil { 5475 l = m.Query.SizeVT() 5476 n += 1 + l + sov(uint64(l)) 5477 } 5478 if m.Options != nil { 5479 l = m.Options.SizeVT() 5480 n += 1 + l + sov(uint64(l)) 5481 } 5482 if len(m.PreQueries) > 0 { 5483 for _, s := range m.PreQueries { 5484 l = len(s) 5485 n += 1 + l + sov(uint64(l)) 5486 } 5487 } 5488 if len(m.PostBeginQueries) > 0 { 5489 for _, s := range m.PostBeginQueries { 5490 l = len(s) 5491 n += 1 + l + sov(uint64(l)) 5492 } 5493 } 5494 if m.unknownFields != nil { 5495 n += len(m.unknownFields) 5496 } 5497 return n 5498 } 5499 5500 func (m *ReserveBeginStreamExecuteResponse) SizeVT() (n int) { 5501 if m == nil { 5502 return 0 5503 } 5504 var l int 5505 _ = l 5506 if m.Error != nil { 5507 l = m.Error.SizeVT() 5508 n += 1 + l + sov(uint64(l)) 5509 } 5510 if m.Result != nil { 5511 l = m.Result.SizeVT() 5512 n += 1 + l + sov(uint64(l)) 5513 } 5514 if m.TransactionId != 0 { 5515 n += 1 + sov(uint64(m.TransactionId)) 5516 } 5517 if m.ReservedId != 0 { 5518 n += 1 + sov(uint64(m.ReservedId)) 5519 } 5520 if m.TabletAlias != nil { 5521 l = m.TabletAlias.SizeVT() 5522 n += 1 + l + sov(uint64(l)) 5523 } 5524 if m.unknownFields != nil { 5525 n += len(m.unknownFields) 5526 } 5527 return n 5528 } 5529 5530 func (m *ReleaseRequest) SizeVT() (n int) { 5531 if m == nil { 5532 return 0 5533 } 5534 var l int 5535 _ = l 5536 if m.EffectiveCallerId != nil { 5537 l = m.EffectiveCallerId.SizeVT() 5538 n += 1 + l + sov(uint64(l)) 5539 } 5540 if m.ImmediateCallerId != nil { 5541 l = m.ImmediateCallerId.SizeVT() 5542 n += 1 + l + sov(uint64(l)) 5543 } 5544 if m.Target != nil { 5545 l = m.Target.SizeVT() 5546 n += 1 + l + sov(uint64(l)) 5547 } 5548 if m.TransactionId != 0 { 5549 n += 1 + sov(uint64(m.TransactionId)) 5550 } 5551 if m.ReservedId != 0 { 5552 n += 1 + sov(uint64(m.ReservedId)) 5553 } 5554 if m.unknownFields != nil { 5555 n += len(m.unknownFields) 5556 } 5557 return n 5558 } 5559 5560 func (m *ReleaseResponse) SizeVT() (n int) { 5561 if m == nil { 5562 return 0 5563 } 5564 var l int 5565 _ = l 5566 if m.unknownFields != nil { 5567 n += len(m.unknownFields) 5568 } 5569 return n 5570 } 5571 5572 func (m *StreamHealthRequest) SizeVT() (n int) { 5573 if m == nil { 5574 return 0 5575 } 5576 var l int 5577 _ = l 5578 if m.unknownFields != nil { 5579 n += len(m.unknownFields) 5580 } 5581 return n 5582 } 5583 5584 func (m *RealtimeStats) SizeVT() (n int) { 5585 if m == nil { 5586 return 0 5587 } 5588 var l int 5589 _ = l 5590 l = len(m.HealthError) 5591 if l > 0 { 5592 n += 1 + l + sov(uint64(l)) 5593 } 5594 if m.ReplicationLagSeconds != 0 { 5595 n += 1 + sov(uint64(m.ReplicationLagSeconds)) 5596 } 5597 if m.BinlogPlayersCount != 0 { 5598 n += 1 + sov(uint64(m.BinlogPlayersCount)) 5599 } 5600 if m.FilteredReplicationLagSeconds != 0 { 5601 n += 1 + sov(uint64(m.FilteredReplicationLagSeconds)) 5602 } 5603 if m.CpuUsage != 0 { 5604 n += 9 5605 } 5606 if m.Qps != 0 { 5607 n += 9 5608 } 5609 if len(m.TableSchemaChanged) > 0 { 5610 for _, s := range m.TableSchemaChanged { 5611 l = len(s) 5612 n += 1 + l + sov(uint64(l)) 5613 } 5614 } 5615 if m.unknownFields != nil { 5616 n += len(m.unknownFields) 5617 } 5618 return n 5619 } 5620 5621 func (m *AggregateStats) SizeVT() (n int) { 5622 if m == nil { 5623 return 0 5624 } 5625 var l int 5626 _ = l 5627 if m.HealthyTabletCount != 0 { 5628 n += 1 + sov(uint64(m.HealthyTabletCount)) 5629 } 5630 if m.UnhealthyTabletCount != 0 { 5631 n += 1 + sov(uint64(m.UnhealthyTabletCount)) 5632 } 5633 if m.ReplicationLagSecondsMin != 0 { 5634 n += 1 + sov(uint64(m.ReplicationLagSecondsMin)) 5635 } 5636 if m.ReplicationLagSecondsMax != 0 { 5637 n += 1 + sov(uint64(m.ReplicationLagSecondsMax)) 5638 } 5639 if m.unknownFields != nil { 5640 n += len(m.unknownFields) 5641 } 5642 return n 5643 } 5644 5645 func (m *StreamHealthResponse) SizeVT() (n int) { 5646 if m == nil { 5647 return 0 5648 } 5649 var l int 5650 _ = l 5651 if m.Target != nil { 5652 l = m.Target.SizeVT() 5653 n += 1 + l + sov(uint64(l)) 5654 } 5655 if m.Serving { 5656 n += 2 5657 } 5658 if m.TabletExternallyReparentedTimestamp != 0 { 5659 n += 1 + sov(uint64(m.TabletExternallyReparentedTimestamp)) 5660 } 5661 if m.RealtimeStats != nil { 5662 l = m.RealtimeStats.SizeVT() 5663 n += 1 + l + sov(uint64(l)) 5664 } 5665 if m.TabletAlias != nil { 5666 l = m.TabletAlias.SizeVT() 5667 n += 1 + l + sov(uint64(l)) 5668 } 5669 if m.unknownFields != nil { 5670 n += len(m.unknownFields) 5671 } 5672 return n 5673 } 5674 5675 func (m *TransactionMetadata) SizeVT() (n int) { 5676 if m == nil { 5677 return 0 5678 } 5679 var l int 5680 _ = l 5681 l = len(m.Dtid) 5682 if l > 0 { 5683 n += 1 + l + sov(uint64(l)) 5684 } 5685 if m.State != 0 { 5686 n += 1 + sov(uint64(m.State)) 5687 } 5688 if m.TimeCreated != 0 { 5689 n += 1 + sov(uint64(m.TimeCreated)) 5690 } 5691 if len(m.Participants) > 0 { 5692 for _, e := range m.Participants { 5693 l = e.SizeVT() 5694 n += 1 + l + sov(uint64(l)) 5695 } 5696 } 5697 if m.unknownFields != nil { 5698 n += len(m.unknownFields) 5699 } 5700 return n 5701 } 5702 5703 func sov(x uint64) (n int) { 5704 return (bits.Len64(x|1) + 6) / 7 5705 } 5706 func soz(x uint64) (n int) { 5707 return sov(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 5708 } 5709 func (m *Target) UnmarshalVT(dAtA []byte) error { 5710 l := len(dAtA) 5711 iNdEx := 0 5712 for iNdEx < l { 5713 preIndex := iNdEx 5714 var wire uint64 5715 for shift := uint(0); ; shift += 7 { 5716 if shift >= 64 { 5717 return ErrIntOverflow 5718 } 5719 if iNdEx >= l { 5720 return io.ErrUnexpectedEOF 5721 } 5722 b := dAtA[iNdEx] 5723 iNdEx++ 5724 wire |= uint64(b&0x7F) << shift 5725 if b < 0x80 { 5726 break 5727 } 5728 } 5729 fieldNum := int32(wire >> 3) 5730 wireType := int(wire & 0x7) 5731 if wireType == 4 { 5732 return fmt.Errorf("proto: Target: wiretype end group for non-group") 5733 } 5734 if fieldNum <= 0 { 5735 return fmt.Errorf("proto: Target: illegal tag %d (wire type %d)", fieldNum, wire) 5736 } 5737 switch fieldNum { 5738 case 1: 5739 if wireType != 2 { 5740 return fmt.Errorf("proto: wrong wireType = %d for field Keyspace", wireType) 5741 } 5742 var stringLen uint64 5743 for shift := uint(0); ; shift += 7 { 5744 if shift >= 64 { 5745 return ErrIntOverflow 5746 } 5747 if iNdEx >= l { 5748 return io.ErrUnexpectedEOF 5749 } 5750 b := dAtA[iNdEx] 5751 iNdEx++ 5752 stringLen |= uint64(b&0x7F) << shift 5753 if b < 0x80 { 5754 break 5755 } 5756 } 5757 intStringLen := int(stringLen) 5758 if intStringLen < 0 { 5759 return ErrInvalidLength 5760 } 5761 postIndex := iNdEx + intStringLen 5762 if postIndex < 0 { 5763 return ErrInvalidLength 5764 } 5765 if postIndex > l { 5766 return io.ErrUnexpectedEOF 5767 } 5768 m.Keyspace = string(dAtA[iNdEx:postIndex]) 5769 iNdEx = postIndex 5770 case 2: 5771 if wireType != 2 { 5772 return fmt.Errorf("proto: wrong wireType = %d for field Shard", wireType) 5773 } 5774 var stringLen uint64 5775 for shift := uint(0); ; shift += 7 { 5776 if shift >= 64 { 5777 return ErrIntOverflow 5778 } 5779 if iNdEx >= l { 5780 return io.ErrUnexpectedEOF 5781 } 5782 b := dAtA[iNdEx] 5783 iNdEx++ 5784 stringLen |= uint64(b&0x7F) << shift 5785 if b < 0x80 { 5786 break 5787 } 5788 } 5789 intStringLen := int(stringLen) 5790 if intStringLen < 0 { 5791 return ErrInvalidLength 5792 } 5793 postIndex := iNdEx + intStringLen 5794 if postIndex < 0 { 5795 return ErrInvalidLength 5796 } 5797 if postIndex > l { 5798 return io.ErrUnexpectedEOF 5799 } 5800 m.Shard = string(dAtA[iNdEx:postIndex]) 5801 iNdEx = postIndex 5802 case 3: 5803 if wireType != 0 { 5804 return fmt.Errorf("proto: wrong wireType = %d for field TabletType", wireType) 5805 } 5806 m.TabletType = 0 5807 for shift := uint(0); ; shift += 7 { 5808 if shift >= 64 { 5809 return ErrIntOverflow 5810 } 5811 if iNdEx >= l { 5812 return io.ErrUnexpectedEOF 5813 } 5814 b := dAtA[iNdEx] 5815 iNdEx++ 5816 m.TabletType |= topodata.TabletType(b&0x7F) << shift 5817 if b < 0x80 { 5818 break 5819 } 5820 } 5821 case 4: 5822 if wireType != 2 { 5823 return fmt.Errorf("proto: wrong wireType = %d for field Cell", wireType) 5824 } 5825 var stringLen uint64 5826 for shift := uint(0); ; shift += 7 { 5827 if shift >= 64 { 5828 return ErrIntOverflow 5829 } 5830 if iNdEx >= l { 5831 return io.ErrUnexpectedEOF 5832 } 5833 b := dAtA[iNdEx] 5834 iNdEx++ 5835 stringLen |= uint64(b&0x7F) << shift 5836 if b < 0x80 { 5837 break 5838 } 5839 } 5840 intStringLen := int(stringLen) 5841 if intStringLen < 0 { 5842 return ErrInvalidLength 5843 } 5844 postIndex := iNdEx + intStringLen 5845 if postIndex < 0 { 5846 return ErrInvalidLength 5847 } 5848 if postIndex > l { 5849 return io.ErrUnexpectedEOF 5850 } 5851 m.Cell = string(dAtA[iNdEx:postIndex]) 5852 iNdEx = postIndex 5853 default: 5854 iNdEx = preIndex 5855 skippy, err := skip(dAtA[iNdEx:]) 5856 if err != nil { 5857 return err 5858 } 5859 if (skippy < 0) || (iNdEx+skippy) < 0 { 5860 return ErrInvalidLength 5861 } 5862 if (iNdEx + skippy) > l { 5863 return io.ErrUnexpectedEOF 5864 } 5865 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 5866 iNdEx += skippy 5867 } 5868 } 5869 5870 if iNdEx > l { 5871 return io.ErrUnexpectedEOF 5872 } 5873 return nil 5874 } 5875 func (m *VTGateCallerID) UnmarshalVT(dAtA []byte) error { 5876 l := len(dAtA) 5877 iNdEx := 0 5878 for iNdEx < l { 5879 preIndex := iNdEx 5880 var wire uint64 5881 for shift := uint(0); ; shift += 7 { 5882 if shift >= 64 { 5883 return ErrIntOverflow 5884 } 5885 if iNdEx >= l { 5886 return io.ErrUnexpectedEOF 5887 } 5888 b := dAtA[iNdEx] 5889 iNdEx++ 5890 wire |= uint64(b&0x7F) << shift 5891 if b < 0x80 { 5892 break 5893 } 5894 } 5895 fieldNum := int32(wire >> 3) 5896 wireType := int(wire & 0x7) 5897 if wireType == 4 { 5898 return fmt.Errorf("proto: VTGateCallerID: wiretype end group for non-group") 5899 } 5900 if fieldNum <= 0 { 5901 return fmt.Errorf("proto: VTGateCallerID: illegal tag %d (wire type %d)", fieldNum, wire) 5902 } 5903 switch fieldNum { 5904 case 1: 5905 if wireType != 2 { 5906 return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType) 5907 } 5908 var stringLen uint64 5909 for shift := uint(0); ; shift += 7 { 5910 if shift >= 64 { 5911 return ErrIntOverflow 5912 } 5913 if iNdEx >= l { 5914 return io.ErrUnexpectedEOF 5915 } 5916 b := dAtA[iNdEx] 5917 iNdEx++ 5918 stringLen |= uint64(b&0x7F) << shift 5919 if b < 0x80 { 5920 break 5921 } 5922 } 5923 intStringLen := int(stringLen) 5924 if intStringLen < 0 { 5925 return ErrInvalidLength 5926 } 5927 postIndex := iNdEx + intStringLen 5928 if postIndex < 0 { 5929 return ErrInvalidLength 5930 } 5931 if postIndex > l { 5932 return io.ErrUnexpectedEOF 5933 } 5934 m.Username = string(dAtA[iNdEx:postIndex]) 5935 iNdEx = postIndex 5936 case 2: 5937 if wireType != 2 { 5938 return fmt.Errorf("proto: wrong wireType = %d for field Groups", wireType) 5939 } 5940 var stringLen uint64 5941 for shift := uint(0); ; shift += 7 { 5942 if shift >= 64 { 5943 return ErrIntOverflow 5944 } 5945 if iNdEx >= l { 5946 return io.ErrUnexpectedEOF 5947 } 5948 b := dAtA[iNdEx] 5949 iNdEx++ 5950 stringLen |= uint64(b&0x7F) << shift 5951 if b < 0x80 { 5952 break 5953 } 5954 } 5955 intStringLen := int(stringLen) 5956 if intStringLen < 0 { 5957 return ErrInvalidLength 5958 } 5959 postIndex := iNdEx + intStringLen 5960 if postIndex < 0 { 5961 return ErrInvalidLength 5962 } 5963 if postIndex > l { 5964 return io.ErrUnexpectedEOF 5965 } 5966 m.Groups = append(m.Groups, string(dAtA[iNdEx:postIndex])) 5967 iNdEx = postIndex 5968 default: 5969 iNdEx = preIndex 5970 skippy, err := skip(dAtA[iNdEx:]) 5971 if err != nil { 5972 return err 5973 } 5974 if (skippy < 0) || (iNdEx+skippy) < 0 { 5975 return ErrInvalidLength 5976 } 5977 if (iNdEx + skippy) > l { 5978 return io.ErrUnexpectedEOF 5979 } 5980 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 5981 iNdEx += skippy 5982 } 5983 } 5984 5985 if iNdEx > l { 5986 return io.ErrUnexpectedEOF 5987 } 5988 return nil 5989 } 5990 func (m *EventToken) UnmarshalVT(dAtA []byte) error { 5991 l := len(dAtA) 5992 iNdEx := 0 5993 for iNdEx < l { 5994 preIndex := iNdEx 5995 var wire uint64 5996 for shift := uint(0); ; shift += 7 { 5997 if shift >= 64 { 5998 return ErrIntOverflow 5999 } 6000 if iNdEx >= l { 6001 return io.ErrUnexpectedEOF 6002 } 6003 b := dAtA[iNdEx] 6004 iNdEx++ 6005 wire |= uint64(b&0x7F) << shift 6006 if b < 0x80 { 6007 break 6008 } 6009 } 6010 fieldNum := int32(wire >> 3) 6011 wireType := int(wire & 0x7) 6012 if wireType == 4 { 6013 return fmt.Errorf("proto: EventToken: wiretype end group for non-group") 6014 } 6015 if fieldNum <= 0 { 6016 return fmt.Errorf("proto: EventToken: illegal tag %d (wire type %d)", fieldNum, wire) 6017 } 6018 switch fieldNum { 6019 case 1: 6020 if wireType != 0 { 6021 return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) 6022 } 6023 m.Timestamp = 0 6024 for shift := uint(0); ; shift += 7 { 6025 if shift >= 64 { 6026 return ErrIntOverflow 6027 } 6028 if iNdEx >= l { 6029 return io.ErrUnexpectedEOF 6030 } 6031 b := dAtA[iNdEx] 6032 iNdEx++ 6033 m.Timestamp |= int64(b&0x7F) << shift 6034 if b < 0x80 { 6035 break 6036 } 6037 } 6038 case 2: 6039 if wireType != 2 { 6040 return fmt.Errorf("proto: wrong wireType = %d for field Shard", wireType) 6041 } 6042 var stringLen uint64 6043 for shift := uint(0); ; shift += 7 { 6044 if shift >= 64 { 6045 return ErrIntOverflow 6046 } 6047 if iNdEx >= l { 6048 return io.ErrUnexpectedEOF 6049 } 6050 b := dAtA[iNdEx] 6051 iNdEx++ 6052 stringLen |= uint64(b&0x7F) << shift 6053 if b < 0x80 { 6054 break 6055 } 6056 } 6057 intStringLen := int(stringLen) 6058 if intStringLen < 0 { 6059 return ErrInvalidLength 6060 } 6061 postIndex := iNdEx + intStringLen 6062 if postIndex < 0 { 6063 return ErrInvalidLength 6064 } 6065 if postIndex > l { 6066 return io.ErrUnexpectedEOF 6067 } 6068 m.Shard = string(dAtA[iNdEx:postIndex]) 6069 iNdEx = postIndex 6070 case 3: 6071 if wireType != 2 { 6072 return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType) 6073 } 6074 var stringLen uint64 6075 for shift := uint(0); ; shift += 7 { 6076 if shift >= 64 { 6077 return ErrIntOverflow 6078 } 6079 if iNdEx >= l { 6080 return io.ErrUnexpectedEOF 6081 } 6082 b := dAtA[iNdEx] 6083 iNdEx++ 6084 stringLen |= uint64(b&0x7F) << shift 6085 if b < 0x80 { 6086 break 6087 } 6088 } 6089 intStringLen := int(stringLen) 6090 if intStringLen < 0 { 6091 return ErrInvalidLength 6092 } 6093 postIndex := iNdEx + intStringLen 6094 if postIndex < 0 { 6095 return ErrInvalidLength 6096 } 6097 if postIndex > l { 6098 return io.ErrUnexpectedEOF 6099 } 6100 m.Position = string(dAtA[iNdEx:postIndex]) 6101 iNdEx = postIndex 6102 default: 6103 iNdEx = preIndex 6104 skippy, err := skip(dAtA[iNdEx:]) 6105 if err != nil { 6106 return err 6107 } 6108 if (skippy < 0) || (iNdEx+skippy) < 0 { 6109 return ErrInvalidLength 6110 } 6111 if (iNdEx + skippy) > l { 6112 return io.ErrUnexpectedEOF 6113 } 6114 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 6115 iNdEx += skippy 6116 } 6117 } 6118 6119 if iNdEx > l { 6120 return io.ErrUnexpectedEOF 6121 } 6122 return nil 6123 } 6124 func (m *Value) UnmarshalVT(dAtA []byte) error { 6125 l := len(dAtA) 6126 iNdEx := 0 6127 for iNdEx < l { 6128 preIndex := iNdEx 6129 var wire uint64 6130 for shift := uint(0); ; shift += 7 { 6131 if shift >= 64 { 6132 return ErrIntOverflow 6133 } 6134 if iNdEx >= l { 6135 return io.ErrUnexpectedEOF 6136 } 6137 b := dAtA[iNdEx] 6138 iNdEx++ 6139 wire |= uint64(b&0x7F) << shift 6140 if b < 0x80 { 6141 break 6142 } 6143 } 6144 fieldNum := int32(wire >> 3) 6145 wireType := int(wire & 0x7) 6146 if wireType == 4 { 6147 return fmt.Errorf("proto: Value: wiretype end group for non-group") 6148 } 6149 if fieldNum <= 0 { 6150 return fmt.Errorf("proto: Value: illegal tag %d (wire type %d)", fieldNum, wire) 6151 } 6152 switch fieldNum { 6153 case 1: 6154 if wireType != 0 { 6155 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 6156 } 6157 m.Type = 0 6158 for shift := uint(0); ; shift += 7 { 6159 if shift >= 64 { 6160 return ErrIntOverflow 6161 } 6162 if iNdEx >= l { 6163 return io.ErrUnexpectedEOF 6164 } 6165 b := dAtA[iNdEx] 6166 iNdEx++ 6167 m.Type |= Type(b&0x7F) << shift 6168 if b < 0x80 { 6169 break 6170 } 6171 } 6172 case 2: 6173 if wireType != 2 { 6174 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 6175 } 6176 var byteLen int 6177 for shift := uint(0); ; shift += 7 { 6178 if shift >= 64 { 6179 return ErrIntOverflow 6180 } 6181 if iNdEx >= l { 6182 return io.ErrUnexpectedEOF 6183 } 6184 b := dAtA[iNdEx] 6185 iNdEx++ 6186 byteLen |= int(b&0x7F) << shift 6187 if b < 0x80 { 6188 break 6189 } 6190 } 6191 if byteLen < 0 { 6192 return ErrInvalidLength 6193 } 6194 postIndex := iNdEx + byteLen 6195 if postIndex < 0 { 6196 return ErrInvalidLength 6197 } 6198 if postIndex > l { 6199 return io.ErrUnexpectedEOF 6200 } 6201 m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) 6202 if m.Value == nil { 6203 m.Value = []byte{} 6204 } 6205 iNdEx = postIndex 6206 default: 6207 iNdEx = preIndex 6208 skippy, err := skip(dAtA[iNdEx:]) 6209 if err != nil { 6210 return err 6211 } 6212 if (skippy < 0) || (iNdEx+skippy) < 0 { 6213 return ErrInvalidLength 6214 } 6215 if (iNdEx + skippy) > l { 6216 return io.ErrUnexpectedEOF 6217 } 6218 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 6219 iNdEx += skippy 6220 } 6221 } 6222 6223 if iNdEx > l { 6224 return io.ErrUnexpectedEOF 6225 } 6226 return nil 6227 } 6228 func (m *BindVariable) UnmarshalVT(dAtA []byte) error { 6229 l := len(dAtA) 6230 iNdEx := 0 6231 for iNdEx < l { 6232 preIndex := iNdEx 6233 var wire uint64 6234 for shift := uint(0); ; shift += 7 { 6235 if shift >= 64 { 6236 return ErrIntOverflow 6237 } 6238 if iNdEx >= l { 6239 return io.ErrUnexpectedEOF 6240 } 6241 b := dAtA[iNdEx] 6242 iNdEx++ 6243 wire |= uint64(b&0x7F) << shift 6244 if b < 0x80 { 6245 break 6246 } 6247 } 6248 fieldNum := int32(wire >> 3) 6249 wireType := int(wire & 0x7) 6250 if wireType == 4 { 6251 return fmt.Errorf("proto: BindVariable: wiretype end group for non-group") 6252 } 6253 if fieldNum <= 0 { 6254 return fmt.Errorf("proto: BindVariable: illegal tag %d (wire type %d)", fieldNum, wire) 6255 } 6256 switch fieldNum { 6257 case 1: 6258 if wireType != 0 { 6259 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 6260 } 6261 m.Type = 0 6262 for shift := uint(0); ; shift += 7 { 6263 if shift >= 64 { 6264 return ErrIntOverflow 6265 } 6266 if iNdEx >= l { 6267 return io.ErrUnexpectedEOF 6268 } 6269 b := dAtA[iNdEx] 6270 iNdEx++ 6271 m.Type |= Type(b&0x7F) << shift 6272 if b < 0x80 { 6273 break 6274 } 6275 } 6276 case 2: 6277 if wireType != 2 { 6278 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 6279 } 6280 var byteLen int 6281 for shift := uint(0); ; shift += 7 { 6282 if shift >= 64 { 6283 return ErrIntOverflow 6284 } 6285 if iNdEx >= l { 6286 return io.ErrUnexpectedEOF 6287 } 6288 b := dAtA[iNdEx] 6289 iNdEx++ 6290 byteLen |= int(b&0x7F) << shift 6291 if b < 0x80 { 6292 break 6293 } 6294 } 6295 if byteLen < 0 { 6296 return ErrInvalidLength 6297 } 6298 postIndex := iNdEx + byteLen 6299 if postIndex < 0 { 6300 return ErrInvalidLength 6301 } 6302 if postIndex > l { 6303 return io.ErrUnexpectedEOF 6304 } 6305 m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) 6306 if m.Value == nil { 6307 m.Value = []byte{} 6308 } 6309 iNdEx = postIndex 6310 case 3: 6311 if wireType != 2 { 6312 return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType) 6313 } 6314 var msglen int 6315 for shift := uint(0); ; shift += 7 { 6316 if shift >= 64 { 6317 return ErrIntOverflow 6318 } 6319 if iNdEx >= l { 6320 return io.ErrUnexpectedEOF 6321 } 6322 b := dAtA[iNdEx] 6323 iNdEx++ 6324 msglen |= int(b&0x7F) << shift 6325 if b < 0x80 { 6326 break 6327 } 6328 } 6329 if msglen < 0 { 6330 return ErrInvalidLength 6331 } 6332 postIndex := iNdEx + msglen 6333 if postIndex < 0 { 6334 return ErrInvalidLength 6335 } 6336 if postIndex > l { 6337 return io.ErrUnexpectedEOF 6338 } 6339 m.Values = append(m.Values, &Value{}) 6340 if err := m.Values[len(m.Values)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 6341 return err 6342 } 6343 iNdEx = postIndex 6344 default: 6345 iNdEx = preIndex 6346 skippy, err := skip(dAtA[iNdEx:]) 6347 if err != nil { 6348 return err 6349 } 6350 if (skippy < 0) || (iNdEx+skippy) < 0 { 6351 return ErrInvalidLength 6352 } 6353 if (iNdEx + skippy) > l { 6354 return io.ErrUnexpectedEOF 6355 } 6356 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 6357 iNdEx += skippy 6358 } 6359 } 6360 6361 if iNdEx > l { 6362 return io.ErrUnexpectedEOF 6363 } 6364 return nil 6365 } 6366 func (m *BoundQuery) UnmarshalVT(dAtA []byte) error { 6367 l := len(dAtA) 6368 iNdEx := 0 6369 for iNdEx < l { 6370 preIndex := iNdEx 6371 var wire uint64 6372 for shift := uint(0); ; shift += 7 { 6373 if shift >= 64 { 6374 return ErrIntOverflow 6375 } 6376 if iNdEx >= l { 6377 return io.ErrUnexpectedEOF 6378 } 6379 b := dAtA[iNdEx] 6380 iNdEx++ 6381 wire |= uint64(b&0x7F) << shift 6382 if b < 0x80 { 6383 break 6384 } 6385 } 6386 fieldNum := int32(wire >> 3) 6387 wireType := int(wire & 0x7) 6388 if wireType == 4 { 6389 return fmt.Errorf("proto: BoundQuery: wiretype end group for non-group") 6390 } 6391 if fieldNum <= 0 { 6392 return fmt.Errorf("proto: BoundQuery: illegal tag %d (wire type %d)", fieldNum, wire) 6393 } 6394 switch fieldNum { 6395 case 1: 6396 if wireType != 2 { 6397 return fmt.Errorf("proto: wrong wireType = %d for field Sql", wireType) 6398 } 6399 var stringLen uint64 6400 for shift := uint(0); ; shift += 7 { 6401 if shift >= 64 { 6402 return ErrIntOverflow 6403 } 6404 if iNdEx >= l { 6405 return io.ErrUnexpectedEOF 6406 } 6407 b := dAtA[iNdEx] 6408 iNdEx++ 6409 stringLen |= uint64(b&0x7F) << shift 6410 if b < 0x80 { 6411 break 6412 } 6413 } 6414 intStringLen := int(stringLen) 6415 if intStringLen < 0 { 6416 return ErrInvalidLength 6417 } 6418 postIndex := iNdEx + intStringLen 6419 if postIndex < 0 { 6420 return ErrInvalidLength 6421 } 6422 if postIndex > l { 6423 return io.ErrUnexpectedEOF 6424 } 6425 m.Sql = string(dAtA[iNdEx:postIndex]) 6426 iNdEx = postIndex 6427 case 2: 6428 if wireType != 2 { 6429 return fmt.Errorf("proto: wrong wireType = %d for field BindVariables", wireType) 6430 } 6431 var msglen int 6432 for shift := uint(0); ; shift += 7 { 6433 if shift >= 64 { 6434 return ErrIntOverflow 6435 } 6436 if iNdEx >= l { 6437 return io.ErrUnexpectedEOF 6438 } 6439 b := dAtA[iNdEx] 6440 iNdEx++ 6441 msglen |= int(b&0x7F) << shift 6442 if b < 0x80 { 6443 break 6444 } 6445 } 6446 if msglen < 0 { 6447 return ErrInvalidLength 6448 } 6449 postIndex := iNdEx + msglen 6450 if postIndex < 0 { 6451 return ErrInvalidLength 6452 } 6453 if postIndex > l { 6454 return io.ErrUnexpectedEOF 6455 } 6456 if m.BindVariables == nil { 6457 m.BindVariables = make(map[string]*BindVariable) 6458 } 6459 var mapkey string 6460 var mapvalue *BindVariable 6461 for iNdEx < postIndex { 6462 entryPreIndex := iNdEx 6463 var wire uint64 6464 for shift := uint(0); ; shift += 7 { 6465 if shift >= 64 { 6466 return ErrIntOverflow 6467 } 6468 if iNdEx >= l { 6469 return io.ErrUnexpectedEOF 6470 } 6471 b := dAtA[iNdEx] 6472 iNdEx++ 6473 wire |= uint64(b&0x7F) << shift 6474 if b < 0x80 { 6475 break 6476 } 6477 } 6478 fieldNum := int32(wire >> 3) 6479 if fieldNum == 1 { 6480 var stringLenmapkey uint64 6481 for shift := uint(0); ; shift += 7 { 6482 if shift >= 64 { 6483 return ErrIntOverflow 6484 } 6485 if iNdEx >= l { 6486 return io.ErrUnexpectedEOF 6487 } 6488 b := dAtA[iNdEx] 6489 iNdEx++ 6490 stringLenmapkey |= uint64(b&0x7F) << shift 6491 if b < 0x80 { 6492 break 6493 } 6494 } 6495 intStringLenmapkey := int(stringLenmapkey) 6496 if intStringLenmapkey < 0 { 6497 return ErrInvalidLength 6498 } 6499 postStringIndexmapkey := iNdEx + intStringLenmapkey 6500 if postStringIndexmapkey < 0 { 6501 return ErrInvalidLength 6502 } 6503 if postStringIndexmapkey > l { 6504 return io.ErrUnexpectedEOF 6505 } 6506 mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) 6507 iNdEx = postStringIndexmapkey 6508 } else if fieldNum == 2 { 6509 var mapmsglen int 6510 for shift := uint(0); ; shift += 7 { 6511 if shift >= 64 { 6512 return ErrIntOverflow 6513 } 6514 if iNdEx >= l { 6515 return io.ErrUnexpectedEOF 6516 } 6517 b := dAtA[iNdEx] 6518 iNdEx++ 6519 mapmsglen |= int(b&0x7F) << shift 6520 if b < 0x80 { 6521 break 6522 } 6523 } 6524 if mapmsglen < 0 { 6525 return ErrInvalidLength 6526 } 6527 postmsgIndex := iNdEx + mapmsglen 6528 if postmsgIndex < 0 { 6529 return ErrInvalidLength 6530 } 6531 if postmsgIndex > l { 6532 return io.ErrUnexpectedEOF 6533 } 6534 mapvalue = &BindVariable{} 6535 if err := mapvalue.UnmarshalVT(dAtA[iNdEx:postmsgIndex]); err != nil { 6536 return err 6537 } 6538 iNdEx = postmsgIndex 6539 } else { 6540 iNdEx = entryPreIndex 6541 skippy, err := skip(dAtA[iNdEx:]) 6542 if err != nil { 6543 return err 6544 } 6545 if (skippy < 0) || (iNdEx+skippy) < 0 { 6546 return ErrInvalidLength 6547 } 6548 if (iNdEx + skippy) > postIndex { 6549 return io.ErrUnexpectedEOF 6550 } 6551 iNdEx += skippy 6552 } 6553 } 6554 m.BindVariables[mapkey] = mapvalue 6555 iNdEx = postIndex 6556 default: 6557 iNdEx = preIndex 6558 skippy, err := skip(dAtA[iNdEx:]) 6559 if err != nil { 6560 return err 6561 } 6562 if (skippy < 0) || (iNdEx+skippy) < 0 { 6563 return ErrInvalidLength 6564 } 6565 if (iNdEx + skippy) > l { 6566 return io.ErrUnexpectedEOF 6567 } 6568 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 6569 iNdEx += skippy 6570 } 6571 } 6572 6573 if iNdEx > l { 6574 return io.ErrUnexpectedEOF 6575 } 6576 return nil 6577 } 6578 func (m *ExecuteOptions) UnmarshalVT(dAtA []byte) error { 6579 l := len(dAtA) 6580 iNdEx := 0 6581 for iNdEx < l { 6582 preIndex := iNdEx 6583 var wire uint64 6584 for shift := uint(0); ; shift += 7 { 6585 if shift >= 64 { 6586 return ErrIntOverflow 6587 } 6588 if iNdEx >= l { 6589 return io.ErrUnexpectedEOF 6590 } 6591 b := dAtA[iNdEx] 6592 iNdEx++ 6593 wire |= uint64(b&0x7F) << shift 6594 if b < 0x80 { 6595 break 6596 } 6597 } 6598 fieldNum := int32(wire >> 3) 6599 wireType := int(wire & 0x7) 6600 if wireType == 4 { 6601 return fmt.Errorf("proto: ExecuteOptions: wiretype end group for non-group") 6602 } 6603 if fieldNum <= 0 { 6604 return fmt.Errorf("proto: ExecuteOptions: illegal tag %d (wire type %d)", fieldNum, wire) 6605 } 6606 switch fieldNum { 6607 case 4: 6608 if wireType != 0 { 6609 return fmt.Errorf("proto: wrong wireType = %d for field IncludedFields", wireType) 6610 } 6611 m.IncludedFields = 0 6612 for shift := uint(0); ; shift += 7 { 6613 if shift >= 64 { 6614 return ErrIntOverflow 6615 } 6616 if iNdEx >= l { 6617 return io.ErrUnexpectedEOF 6618 } 6619 b := dAtA[iNdEx] 6620 iNdEx++ 6621 m.IncludedFields |= ExecuteOptions_IncludedFields(b&0x7F) << shift 6622 if b < 0x80 { 6623 break 6624 } 6625 } 6626 case 5: 6627 if wireType != 0 { 6628 return fmt.Errorf("proto: wrong wireType = %d for field ClientFoundRows", wireType) 6629 } 6630 var v int 6631 for shift := uint(0); ; shift += 7 { 6632 if shift >= 64 { 6633 return ErrIntOverflow 6634 } 6635 if iNdEx >= l { 6636 return io.ErrUnexpectedEOF 6637 } 6638 b := dAtA[iNdEx] 6639 iNdEx++ 6640 v |= int(b&0x7F) << shift 6641 if b < 0x80 { 6642 break 6643 } 6644 } 6645 m.ClientFoundRows = bool(v != 0) 6646 case 6: 6647 if wireType != 0 { 6648 return fmt.Errorf("proto: wrong wireType = %d for field Workload", wireType) 6649 } 6650 m.Workload = 0 6651 for shift := uint(0); ; shift += 7 { 6652 if shift >= 64 { 6653 return ErrIntOverflow 6654 } 6655 if iNdEx >= l { 6656 return io.ErrUnexpectedEOF 6657 } 6658 b := dAtA[iNdEx] 6659 iNdEx++ 6660 m.Workload |= ExecuteOptions_Workload(b&0x7F) << shift 6661 if b < 0x80 { 6662 break 6663 } 6664 } 6665 case 8: 6666 if wireType != 0 { 6667 return fmt.Errorf("proto: wrong wireType = %d for field SqlSelectLimit", wireType) 6668 } 6669 m.SqlSelectLimit = 0 6670 for shift := uint(0); ; shift += 7 { 6671 if shift >= 64 { 6672 return ErrIntOverflow 6673 } 6674 if iNdEx >= l { 6675 return io.ErrUnexpectedEOF 6676 } 6677 b := dAtA[iNdEx] 6678 iNdEx++ 6679 m.SqlSelectLimit |= int64(b&0x7F) << shift 6680 if b < 0x80 { 6681 break 6682 } 6683 } 6684 case 9: 6685 if wireType != 0 { 6686 return fmt.Errorf("proto: wrong wireType = %d for field TransactionIsolation", wireType) 6687 } 6688 m.TransactionIsolation = 0 6689 for shift := uint(0); ; shift += 7 { 6690 if shift >= 64 { 6691 return ErrIntOverflow 6692 } 6693 if iNdEx >= l { 6694 return io.ErrUnexpectedEOF 6695 } 6696 b := dAtA[iNdEx] 6697 iNdEx++ 6698 m.TransactionIsolation |= ExecuteOptions_TransactionIsolation(b&0x7F) << shift 6699 if b < 0x80 { 6700 break 6701 } 6702 } 6703 case 10: 6704 if wireType != 0 { 6705 return fmt.Errorf("proto: wrong wireType = %d for field SkipQueryPlanCache", wireType) 6706 } 6707 var v int 6708 for shift := uint(0); ; shift += 7 { 6709 if shift >= 64 { 6710 return ErrIntOverflow 6711 } 6712 if iNdEx >= l { 6713 return io.ErrUnexpectedEOF 6714 } 6715 b := dAtA[iNdEx] 6716 iNdEx++ 6717 v |= int(b&0x7F) << shift 6718 if b < 0x80 { 6719 break 6720 } 6721 } 6722 m.SkipQueryPlanCache = bool(v != 0) 6723 case 11: 6724 if wireType != 0 { 6725 return fmt.Errorf("proto: wrong wireType = %d for field PlannerVersion", wireType) 6726 } 6727 m.PlannerVersion = 0 6728 for shift := uint(0); ; shift += 7 { 6729 if shift >= 64 { 6730 return ErrIntOverflow 6731 } 6732 if iNdEx >= l { 6733 return io.ErrUnexpectedEOF 6734 } 6735 b := dAtA[iNdEx] 6736 iNdEx++ 6737 m.PlannerVersion |= ExecuteOptions_PlannerVersion(b&0x7F) << shift 6738 if b < 0x80 { 6739 break 6740 } 6741 } 6742 case 12: 6743 if wireType != 0 { 6744 return fmt.Errorf("proto: wrong wireType = %d for field HasCreatedTempTables", wireType) 6745 } 6746 var v int 6747 for shift := uint(0); ; shift += 7 { 6748 if shift >= 64 { 6749 return ErrIntOverflow 6750 } 6751 if iNdEx >= l { 6752 return io.ErrUnexpectedEOF 6753 } 6754 b := dAtA[iNdEx] 6755 iNdEx++ 6756 v |= int(b&0x7F) << shift 6757 if b < 0x80 { 6758 break 6759 } 6760 } 6761 m.HasCreatedTempTables = bool(v != 0) 6762 default: 6763 iNdEx = preIndex 6764 skippy, err := skip(dAtA[iNdEx:]) 6765 if err != nil { 6766 return err 6767 } 6768 if (skippy < 0) || (iNdEx+skippy) < 0 { 6769 return ErrInvalidLength 6770 } 6771 if (iNdEx + skippy) > l { 6772 return io.ErrUnexpectedEOF 6773 } 6774 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 6775 iNdEx += skippy 6776 } 6777 } 6778 6779 if iNdEx > l { 6780 return io.ErrUnexpectedEOF 6781 } 6782 return nil 6783 } 6784 func (m *Field) UnmarshalVT(dAtA []byte) error { 6785 l := len(dAtA) 6786 iNdEx := 0 6787 for iNdEx < l { 6788 preIndex := iNdEx 6789 var wire uint64 6790 for shift := uint(0); ; shift += 7 { 6791 if shift >= 64 { 6792 return ErrIntOverflow 6793 } 6794 if iNdEx >= l { 6795 return io.ErrUnexpectedEOF 6796 } 6797 b := dAtA[iNdEx] 6798 iNdEx++ 6799 wire |= uint64(b&0x7F) << shift 6800 if b < 0x80 { 6801 break 6802 } 6803 } 6804 fieldNum := int32(wire >> 3) 6805 wireType := int(wire & 0x7) 6806 if wireType == 4 { 6807 return fmt.Errorf("proto: Field: wiretype end group for non-group") 6808 } 6809 if fieldNum <= 0 { 6810 return fmt.Errorf("proto: Field: illegal tag %d (wire type %d)", fieldNum, wire) 6811 } 6812 switch fieldNum { 6813 case 1: 6814 if wireType != 2 { 6815 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) 6816 } 6817 var stringLen uint64 6818 for shift := uint(0); ; shift += 7 { 6819 if shift >= 64 { 6820 return ErrIntOverflow 6821 } 6822 if iNdEx >= l { 6823 return io.ErrUnexpectedEOF 6824 } 6825 b := dAtA[iNdEx] 6826 iNdEx++ 6827 stringLen |= uint64(b&0x7F) << shift 6828 if b < 0x80 { 6829 break 6830 } 6831 } 6832 intStringLen := int(stringLen) 6833 if intStringLen < 0 { 6834 return ErrInvalidLength 6835 } 6836 postIndex := iNdEx + intStringLen 6837 if postIndex < 0 { 6838 return ErrInvalidLength 6839 } 6840 if postIndex > l { 6841 return io.ErrUnexpectedEOF 6842 } 6843 m.Name = string(dAtA[iNdEx:postIndex]) 6844 iNdEx = postIndex 6845 case 2: 6846 if wireType != 0 { 6847 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 6848 } 6849 m.Type = 0 6850 for shift := uint(0); ; shift += 7 { 6851 if shift >= 64 { 6852 return ErrIntOverflow 6853 } 6854 if iNdEx >= l { 6855 return io.ErrUnexpectedEOF 6856 } 6857 b := dAtA[iNdEx] 6858 iNdEx++ 6859 m.Type |= Type(b&0x7F) << shift 6860 if b < 0x80 { 6861 break 6862 } 6863 } 6864 case 3: 6865 if wireType != 2 { 6866 return fmt.Errorf("proto: wrong wireType = %d for field Table", wireType) 6867 } 6868 var stringLen uint64 6869 for shift := uint(0); ; shift += 7 { 6870 if shift >= 64 { 6871 return ErrIntOverflow 6872 } 6873 if iNdEx >= l { 6874 return io.ErrUnexpectedEOF 6875 } 6876 b := dAtA[iNdEx] 6877 iNdEx++ 6878 stringLen |= uint64(b&0x7F) << shift 6879 if b < 0x80 { 6880 break 6881 } 6882 } 6883 intStringLen := int(stringLen) 6884 if intStringLen < 0 { 6885 return ErrInvalidLength 6886 } 6887 postIndex := iNdEx + intStringLen 6888 if postIndex < 0 { 6889 return ErrInvalidLength 6890 } 6891 if postIndex > l { 6892 return io.ErrUnexpectedEOF 6893 } 6894 m.Table = string(dAtA[iNdEx:postIndex]) 6895 iNdEx = postIndex 6896 case 4: 6897 if wireType != 2 { 6898 return fmt.Errorf("proto: wrong wireType = %d for field OrgTable", wireType) 6899 } 6900 var stringLen uint64 6901 for shift := uint(0); ; shift += 7 { 6902 if shift >= 64 { 6903 return ErrIntOverflow 6904 } 6905 if iNdEx >= l { 6906 return io.ErrUnexpectedEOF 6907 } 6908 b := dAtA[iNdEx] 6909 iNdEx++ 6910 stringLen |= uint64(b&0x7F) << shift 6911 if b < 0x80 { 6912 break 6913 } 6914 } 6915 intStringLen := int(stringLen) 6916 if intStringLen < 0 { 6917 return ErrInvalidLength 6918 } 6919 postIndex := iNdEx + intStringLen 6920 if postIndex < 0 { 6921 return ErrInvalidLength 6922 } 6923 if postIndex > l { 6924 return io.ErrUnexpectedEOF 6925 } 6926 m.OrgTable = string(dAtA[iNdEx:postIndex]) 6927 iNdEx = postIndex 6928 case 5: 6929 if wireType != 2 { 6930 return fmt.Errorf("proto: wrong wireType = %d for field Database", wireType) 6931 } 6932 var stringLen uint64 6933 for shift := uint(0); ; shift += 7 { 6934 if shift >= 64 { 6935 return ErrIntOverflow 6936 } 6937 if iNdEx >= l { 6938 return io.ErrUnexpectedEOF 6939 } 6940 b := dAtA[iNdEx] 6941 iNdEx++ 6942 stringLen |= uint64(b&0x7F) << shift 6943 if b < 0x80 { 6944 break 6945 } 6946 } 6947 intStringLen := int(stringLen) 6948 if intStringLen < 0 { 6949 return ErrInvalidLength 6950 } 6951 postIndex := iNdEx + intStringLen 6952 if postIndex < 0 { 6953 return ErrInvalidLength 6954 } 6955 if postIndex > l { 6956 return io.ErrUnexpectedEOF 6957 } 6958 m.Database = string(dAtA[iNdEx:postIndex]) 6959 iNdEx = postIndex 6960 case 6: 6961 if wireType != 2 { 6962 return fmt.Errorf("proto: wrong wireType = %d for field OrgName", wireType) 6963 } 6964 var stringLen uint64 6965 for shift := uint(0); ; shift += 7 { 6966 if shift >= 64 { 6967 return ErrIntOverflow 6968 } 6969 if iNdEx >= l { 6970 return io.ErrUnexpectedEOF 6971 } 6972 b := dAtA[iNdEx] 6973 iNdEx++ 6974 stringLen |= uint64(b&0x7F) << shift 6975 if b < 0x80 { 6976 break 6977 } 6978 } 6979 intStringLen := int(stringLen) 6980 if intStringLen < 0 { 6981 return ErrInvalidLength 6982 } 6983 postIndex := iNdEx + intStringLen 6984 if postIndex < 0 { 6985 return ErrInvalidLength 6986 } 6987 if postIndex > l { 6988 return io.ErrUnexpectedEOF 6989 } 6990 m.OrgName = string(dAtA[iNdEx:postIndex]) 6991 iNdEx = postIndex 6992 case 7: 6993 if wireType != 0 { 6994 return fmt.Errorf("proto: wrong wireType = %d for field ColumnLength", wireType) 6995 } 6996 m.ColumnLength = 0 6997 for shift := uint(0); ; shift += 7 { 6998 if shift >= 64 { 6999 return ErrIntOverflow 7000 } 7001 if iNdEx >= l { 7002 return io.ErrUnexpectedEOF 7003 } 7004 b := dAtA[iNdEx] 7005 iNdEx++ 7006 m.ColumnLength |= uint32(b&0x7F) << shift 7007 if b < 0x80 { 7008 break 7009 } 7010 } 7011 case 8: 7012 if wireType != 0 { 7013 return fmt.Errorf("proto: wrong wireType = %d for field Charset", wireType) 7014 } 7015 m.Charset = 0 7016 for shift := uint(0); ; shift += 7 { 7017 if shift >= 64 { 7018 return ErrIntOverflow 7019 } 7020 if iNdEx >= l { 7021 return io.ErrUnexpectedEOF 7022 } 7023 b := dAtA[iNdEx] 7024 iNdEx++ 7025 m.Charset |= uint32(b&0x7F) << shift 7026 if b < 0x80 { 7027 break 7028 } 7029 } 7030 case 9: 7031 if wireType != 0 { 7032 return fmt.Errorf("proto: wrong wireType = %d for field Decimals", wireType) 7033 } 7034 m.Decimals = 0 7035 for shift := uint(0); ; shift += 7 { 7036 if shift >= 64 { 7037 return ErrIntOverflow 7038 } 7039 if iNdEx >= l { 7040 return io.ErrUnexpectedEOF 7041 } 7042 b := dAtA[iNdEx] 7043 iNdEx++ 7044 m.Decimals |= uint32(b&0x7F) << shift 7045 if b < 0x80 { 7046 break 7047 } 7048 } 7049 case 10: 7050 if wireType != 0 { 7051 return fmt.Errorf("proto: wrong wireType = %d for field Flags", wireType) 7052 } 7053 m.Flags = 0 7054 for shift := uint(0); ; shift += 7 { 7055 if shift >= 64 { 7056 return ErrIntOverflow 7057 } 7058 if iNdEx >= l { 7059 return io.ErrUnexpectedEOF 7060 } 7061 b := dAtA[iNdEx] 7062 iNdEx++ 7063 m.Flags |= uint32(b&0x7F) << shift 7064 if b < 0x80 { 7065 break 7066 } 7067 } 7068 case 11: 7069 if wireType != 2 { 7070 return fmt.Errorf("proto: wrong wireType = %d for field ColumnType", wireType) 7071 } 7072 var stringLen uint64 7073 for shift := uint(0); ; shift += 7 { 7074 if shift >= 64 { 7075 return ErrIntOverflow 7076 } 7077 if iNdEx >= l { 7078 return io.ErrUnexpectedEOF 7079 } 7080 b := dAtA[iNdEx] 7081 iNdEx++ 7082 stringLen |= uint64(b&0x7F) << shift 7083 if b < 0x80 { 7084 break 7085 } 7086 } 7087 intStringLen := int(stringLen) 7088 if intStringLen < 0 { 7089 return ErrInvalidLength 7090 } 7091 postIndex := iNdEx + intStringLen 7092 if postIndex < 0 { 7093 return ErrInvalidLength 7094 } 7095 if postIndex > l { 7096 return io.ErrUnexpectedEOF 7097 } 7098 m.ColumnType = string(dAtA[iNdEx:postIndex]) 7099 iNdEx = postIndex 7100 default: 7101 iNdEx = preIndex 7102 skippy, err := skip(dAtA[iNdEx:]) 7103 if err != nil { 7104 return err 7105 } 7106 if (skippy < 0) || (iNdEx+skippy) < 0 { 7107 return ErrInvalidLength 7108 } 7109 if (iNdEx + skippy) > l { 7110 return io.ErrUnexpectedEOF 7111 } 7112 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 7113 iNdEx += skippy 7114 } 7115 } 7116 7117 if iNdEx > l { 7118 return io.ErrUnexpectedEOF 7119 } 7120 return nil 7121 } 7122 func (m *Row) UnmarshalVT(dAtA []byte) error { 7123 l := len(dAtA) 7124 iNdEx := 0 7125 for iNdEx < l { 7126 preIndex := iNdEx 7127 var wire uint64 7128 for shift := uint(0); ; shift += 7 { 7129 if shift >= 64 { 7130 return ErrIntOverflow 7131 } 7132 if iNdEx >= l { 7133 return io.ErrUnexpectedEOF 7134 } 7135 b := dAtA[iNdEx] 7136 iNdEx++ 7137 wire |= uint64(b&0x7F) << shift 7138 if b < 0x80 { 7139 break 7140 } 7141 } 7142 fieldNum := int32(wire >> 3) 7143 wireType := int(wire & 0x7) 7144 if wireType == 4 { 7145 return fmt.Errorf("proto: Row: wiretype end group for non-group") 7146 } 7147 if fieldNum <= 0 { 7148 return fmt.Errorf("proto: Row: illegal tag %d (wire type %d)", fieldNum, wire) 7149 } 7150 switch fieldNum { 7151 case 1: 7152 if wireType == 0 { 7153 var v uint64 7154 for shift := uint(0); ; shift += 7 { 7155 if shift >= 64 { 7156 return ErrIntOverflow 7157 } 7158 if iNdEx >= l { 7159 return io.ErrUnexpectedEOF 7160 } 7161 b := dAtA[iNdEx] 7162 iNdEx++ 7163 v |= uint64(b&0x7F) << shift 7164 if b < 0x80 { 7165 break 7166 } 7167 } 7168 v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) 7169 m.Lengths = append(m.Lengths, int64(v)) 7170 } else if wireType == 2 { 7171 var packedLen int 7172 for shift := uint(0); ; shift += 7 { 7173 if shift >= 64 { 7174 return ErrIntOverflow 7175 } 7176 if iNdEx >= l { 7177 return io.ErrUnexpectedEOF 7178 } 7179 b := dAtA[iNdEx] 7180 iNdEx++ 7181 packedLen |= int(b&0x7F) << shift 7182 if b < 0x80 { 7183 break 7184 } 7185 } 7186 if packedLen < 0 { 7187 return ErrInvalidLength 7188 } 7189 postIndex := iNdEx + packedLen 7190 if postIndex < 0 { 7191 return ErrInvalidLength 7192 } 7193 if postIndex > l { 7194 return io.ErrUnexpectedEOF 7195 } 7196 var elementCount int 7197 var count int 7198 for _, integer := range dAtA[iNdEx:postIndex] { 7199 if integer < 128 { 7200 count++ 7201 } 7202 } 7203 elementCount = count 7204 if elementCount != 0 && len(m.Lengths) == 0 && cap(m.Lengths) < elementCount { 7205 m.Lengths = make([]int64, 0, elementCount) 7206 } 7207 for iNdEx < postIndex { 7208 var v uint64 7209 for shift := uint(0); ; shift += 7 { 7210 if shift >= 64 { 7211 return ErrIntOverflow 7212 } 7213 if iNdEx >= l { 7214 return io.ErrUnexpectedEOF 7215 } 7216 b := dAtA[iNdEx] 7217 iNdEx++ 7218 v |= uint64(b&0x7F) << shift 7219 if b < 0x80 { 7220 break 7221 } 7222 } 7223 v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) 7224 m.Lengths = append(m.Lengths, int64(v)) 7225 } 7226 } else { 7227 return fmt.Errorf("proto: wrong wireType = %d for field Lengths", wireType) 7228 } 7229 case 2: 7230 if wireType != 2 { 7231 return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType) 7232 } 7233 var byteLen int 7234 for shift := uint(0); ; shift += 7 { 7235 if shift >= 64 { 7236 return ErrIntOverflow 7237 } 7238 if iNdEx >= l { 7239 return io.ErrUnexpectedEOF 7240 } 7241 b := dAtA[iNdEx] 7242 iNdEx++ 7243 byteLen |= int(b&0x7F) << shift 7244 if b < 0x80 { 7245 break 7246 } 7247 } 7248 if byteLen < 0 { 7249 return ErrInvalidLength 7250 } 7251 postIndex := iNdEx + byteLen 7252 if postIndex < 0 { 7253 return ErrInvalidLength 7254 } 7255 if postIndex > l { 7256 return io.ErrUnexpectedEOF 7257 } 7258 m.Values = append(m.Values[:0], dAtA[iNdEx:postIndex]...) 7259 if m.Values == nil { 7260 m.Values = []byte{} 7261 } 7262 iNdEx = postIndex 7263 default: 7264 iNdEx = preIndex 7265 skippy, err := skip(dAtA[iNdEx:]) 7266 if err != nil { 7267 return err 7268 } 7269 if (skippy < 0) || (iNdEx+skippy) < 0 { 7270 return ErrInvalidLength 7271 } 7272 if (iNdEx + skippy) > l { 7273 return io.ErrUnexpectedEOF 7274 } 7275 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 7276 iNdEx += skippy 7277 } 7278 } 7279 7280 if iNdEx > l { 7281 return io.ErrUnexpectedEOF 7282 } 7283 return nil 7284 } 7285 func (m *QueryResult) UnmarshalVT(dAtA []byte) error { 7286 l := len(dAtA) 7287 iNdEx := 0 7288 for iNdEx < l { 7289 preIndex := iNdEx 7290 var wire uint64 7291 for shift := uint(0); ; shift += 7 { 7292 if shift >= 64 { 7293 return ErrIntOverflow 7294 } 7295 if iNdEx >= l { 7296 return io.ErrUnexpectedEOF 7297 } 7298 b := dAtA[iNdEx] 7299 iNdEx++ 7300 wire |= uint64(b&0x7F) << shift 7301 if b < 0x80 { 7302 break 7303 } 7304 } 7305 fieldNum := int32(wire >> 3) 7306 wireType := int(wire & 0x7) 7307 if wireType == 4 { 7308 return fmt.Errorf("proto: QueryResult: wiretype end group for non-group") 7309 } 7310 if fieldNum <= 0 { 7311 return fmt.Errorf("proto: QueryResult: illegal tag %d (wire type %d)", fieldNum, wire) 7312 } 7313 switch fieldNum { 7314 case 1: 7315 if wireType != 2 { 7316 return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType) 7317 } 7318 var msglen int 7319 for shift := uint(0); ; shift += 7 { 7320 if shift >= 64 { 7321 return ErrIntOverflow 7322 } 7323 if iNdEx >= l { 7324 return io.ErrUnexpectedEOF 7325 } 7326 b := dAtA[iNdEx] 7327 iNdEx++ 7328 msglen |= int(b&0x7F) << shift 7329 if b < 0x80 { 7330 break 7331 } 7332 } 7333 if msglen < 0 { 7334 return ErrInvalidLength 7335 } 7336 postIndex := iNdEx + msglen 7337 if postIndex < 0 { 7338 return ErrInvalidLength 7339 } 7340 if postIndex > l { 7341 return io.ErrUnexpectedEOF 7342 } 7343 m.Fields = append(m.Fields, &Field{}) 7344 if err := m.Fields[len(m.Fields)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 7345 return err 7346 } 7347 iNdEx = postIndex 7348 case 2: 7349 if wireType != 0 { 7350 return fmt.Errorf("proto: wrong wireType = %d for field RowsAffected", wireType) 7351 } 7352 m.RowsAffected = 0 7353 for shift := uint(0); ; shift += 7 { 7354 if shift >= 64 { 7355 return ErrIntOverflow 7356 } 7357 if iNdEx >= l { 7358 return io.ErrUnexpectedEOF 7359 } 7360 b := dAtA[iNdEx] 7361 iNdEx++ 7362 m.RowsAffected |= uint64(b&0x7F) << shift 7363 if b < 0x80 { 7364 break 7365 } 7366 } 7367 case 3: 7368 if wireType != 0 { 7369 return fmt.Errorf("proto: wrong wireType = %d for field InsertId", wireType) 7370 } 7371 m.InsertId = 0 7372 for shift := uint(0); ; shift += 7 { 7373 if shift >= 64 { 7374 return ErrIntOverflow 7375 } 7376 if iNdEx >= l { 7377 return io.ErrUnexpectedEOF 7378 } 7379 b := dAtA[iNdEx] 7380 iNdEx++ 7381 m.InsertId |= uint64(b&0x7F) << shift 7382 if b < 0x80 { 7383 break 7384 } 7385 } 7386 case 4: 7387 if wireType != 2 { 7388 return fmt.Errorf("proto: wrong wireType = %d for field Rows", wireType) 7389 } 7390 var msglen int 7391 for shift := uint(0); ; shift += 7 { 7392 if shift >= 64 { 7393 return ErrIntOverflow 7394 } 7395 if iNdEx >= l { 7396 return io.ErrUnexpectedEOF 7397 } 7398 b := dAtA[iNdEx] 7399 iNdEx++ 7400 msglen |= int(b&0x7F) << shift 7401 if b < 0x80 { 7402 break 7403 } 7404 } 7405 if msglen < 0 { 7406 return ErrInvalidLength 7407 } 7408 postIndex := iNdEx + msglen 7409 if postIndex < 0 { 7410 return ErrInvalidLength 7411 } 7412 if postIndex > l { 7413 return io.ErrUnexpectedEOF 7414 } 7415 m.Rows = append(m.Rows, &Row{}) 7416 if err := m.Rows[len(m.Rows)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 7417 return err 7418 } 7419 iNdEx = postIndex 7420 default: 7421 iNdEx = preIndex 7422 skippy, err := skip(dAtA[iNdEx:]) 7423 if err != nil { 7424 return err 7425 } 7426 if (skippy < 0) || (iNdEx+skippy) < 0 { 7427 return ErrInvalidLength 7428 } 7429 if (iNdEx + skippy) > l { 7430 return io.ErrUnexpectedEOF 7431 } 7432 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 7433 iNdEx += skippy 7434 } 7435 } 7436 7437 if iNdEx > l { 7438 return io.ErrUnexpectedEOF 7439 } 7440 return nil 7441 } 7442 func (m *QueryWarning) UnmarshalVT(dAtA []byte) error { 7443 l := len(dAtA) 7444 iNdEx := 0 7445 for iNdEx < l { 7446 preIndex := iNdEx 7447 var wire uint64 7448 for shift := uint(0); ; shift += 7 { 7449 if shift >= 64 { 7450 return ErrIntOverflow 7451 } 7452 if iNdEx >= l { 7453 return io.ErrUnexpectedEOF 7454 } 7455 b := dAtA[iNdEx] 7456 iNdEx++ 7457 wire |= uint64(b&0x7F) << shift 7458 if b < 0x80 { 7459 break 7460 } 7461 } 7462 fieldNum := int32(wire >> 3) 7463 wireType := int(wire & 0x7) 7464 if wireType == 4 { 7465 return fmt.Errorf("proto: QueryWarning: wiretype end group for non-group") 7466 } 7467 if fieldNum <= 0 { 7468 return fmt.Errorf("proto: QueryWarning: illegal tag %d (wire type %d)", fieldNum, wire) 7469 } 7470 switch fieldNum { 7471 case 1: 7472 if wireType != 0 { 7473 return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) 7474 } 7475 m.Code = 0 7476 for shift := uint(0); ; shift += 7 { 7477 if shift >= 64 { 7478 return ErrIntOverflow 7479 } 7480 if iNdEx >= l { 7481 return io.ErrUnexpectedEOF 7482 } 7483 b := dAtA[iNdEx] 7484 iNdEx++ 7485 m.Code |= uint32(b&0x7F) << shift 7486 if b < 0x80 { 7487 break 7488 } 7489 } 7490 case 2: 7491 if wireType != 2 { 7492 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) 7493 } 7494 var stringLen uint64 7495 for shift := uint(0); ; shift += 7 { 7496 if shift >= 64 { 7497 return ErrIntOverflow 7498 } 7499 if iNdEx >= l { 7500 return io.ErrUnexpectedEOF 7501 } 7502 b := dAtA[iNdEx] 7503 iNdEx++ 7504 stringLen |= uint64(b&0x7F) << shift 7505 if b < 0x80 { 7506 break 7507 } 7508 } 7509 intStringLen := int(stringLen) 7510 if intStringLen < 0 { 7511 return ErrInvalidLength 7512 } 7513 postIndex := iNdEx + intStringLen 7514 if postIndex < 0 { 7515 return ErrInvalidLength 7516 } 7517 if postIndex > l { 7518 return io.ErrUnexpectedEOF 7519 } 7520 m.Message = string(dAtA[iNdEx:postIndex]) 7521 iNdEx = postIndex 7522 default: 7523 iNdEx = preIndex 7524 skippy, err := skip(dAtA[iNdEx:]) 7525 if err != nil { 7526 return err 7527 } 7528 if (skippy < 0) || (iNdEx+skippy) < 0 { 7529 return ErrInvalidLength 7530 } 7531 if (iNdEx + skippy) > l { 7532 return io.ErrUnexpectedEOF 7533 } 7534 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 7535 iNdEx += skippy 7536 } 7537 } 7538 7539 if iNdEx > l { 7540 return io.ErrUnexpectedEOF 7541 } 7542 return nil 7543 } 7544 func (m *StreamEvent_Statement) UnmarshalVT(dAtA []byte) error { 7545 l := len(dAtA) 7546 iNdEx := 0 7547 for iNdEx < l { 7548 preIndex := iNdEx 7549 var wire uint64 7550 for shift := uint(0); ; shift += 7 { 7551 if shift >= 64 { 7552 return ErrIntOverflow 7553 } 7554 if iNdEx >= l { 7555 return io.ErrUnexpectedEOF 7556 } 7557 b := dAtA[iNdEx] 7558 iNdEx++ 7559 wire |= uint64(b&0x7F) << shift 7560 if b < 0x80 { 7561 break 7562 } 7563 } 7564 fieldNum := int32(wire >> 3) 7565 wireType := int(wire & 0x7) 7566 if wireType == 4 { 7567 return fmt.Errorf("proto: StreamEvent_Statement: wiretype end group for non-group") 7568 } 7569 if fieldNum <= 0 { 7570 return fmt.Errorf("proto: StreamEvent_Statement: illegal tag %d (wire type %d)", fieldNum, wire) 7571 } 7572 switch fieldNum { 7573 case 1: 7574 if wireType != 0 { 7575 return fmt.Errorf("proto: wrong wireType = %d for field Category", wireType) 7576 } 7577 m.Category = 0 7578 for shift := uint(0); ; shift += 7 { 7579 if shift >= 64 { 7580 return ErrIntOverflow 7581 } 7582 if iNdEx >= l { 7583 return io.ErrUnexpectedEOF 7584 } 7585 b := dAtA[iNdEx] 7586 iNdEx++ 7587 m.Category |= StreamEvent_Statement_Category(b&0x7F) << shift 7588 if b < 0x80 { 7589 break 7590 } 7591 } 7592 case 2: 7593 if wireType != 2 { 7594 return fmt.Errorf("proto: wrong wireType = %d for field TableName", wireType) 7595 } 7596 var stringLen uint64 7597 for shift := uint(0); ; shift += 7 { 7598 if shift >= 64 { 7599 return ErrIntOverflow 7600 } 7601 if iNdEx >= l { 7602 return io.ErrUnexpectedEOF 7603 } 7604 b := dAtA[iNdEx] 7605 iNdEx++ 7606 stringLen |= uint64(b&0x7F) << shift 7607 if b < 0x80 { 7608 break 7609 } 7610 } 7611 intStringLen := int(stringLen) 7612 if intStringLen < 0 { 7613 return ErrInvalidLength 7614 } 7615 postIndex := iNdEx + intStringLen 7616 if postIndex < 0 { 7617 return ErrInvalidLength 7618 } 7619 if postIndex > l { 7620 return io.ErrUnexpectedEOF 7621 } 7622 m.TableName = string(dAtA[iNdEx:postIndex]) 7623 iNdEx = postIndex 7624 case 3: 7625 if wireType != 2 { 7626 return fmt.Errorf("proto: wrong wireType = %d for field PrimaryKeyFields", wireType) 7627 } 7628 var msglen int 7629 for shift := uint(0); ; shift += 7 { 7630 if shift >= 64 { 7631 return ErrIntOverflow 7632 } 7633 if iNdEx >= l { 7634 return io.ErrUnexpectedEOF 7635 } 7636 b := dAtA[iNdEx] 7637 iNdEx++ 7638 msglen |= int(b&0x7F) << shift 7639 if b < 0x80 { 7640 break 7641 } 7642 } 7643 if msglen < 0 { 7644 return ErrInvalidLength 7645 } 7646 postIndex := iNdEx + msglen 7647 if postIndex < 0 { 7648 return ErrInvalidLength 7649 } 7650 if postIndex > l { 7651 return io.ErrUnexpectedEOF 7652 } 7653 m.PrimaryKeyFields = append(m.PrimaryKeyFields, &Field{}) 7654 if err := m.PrimaryKeyFields[len(m.PrimaryKeyFields)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 7655 return err 7656 } 7657 iNdEx = postIndex 7658 case 4: 7659 if wireType != 2 { 7660 return fmt.Errorf("proto: wrong wireType = %d for field PrimaryKeyValues", wireType) 7661 } 7662 var msglen int 7663 for shift := uint(0); ; shift += 7 { 7664 if shift >= 64 { 7665 return ErrIntOverflow 7666 } 7667 if iNdEx >= l { 7668 return io.ErrUnexpectedEOF 7669 } 7670 b := dAtA[iNdEx] 7671 iNdEx++ 7672 msglen |= int(b&0x7F) << shift 7673 if b < 0x80 { 7674 break 7675 } 7676 } 7677 if msglen < 0 { 7678 return ErrInvalidLength 7679 } 7680 postIndex := iNdEx + msglen 7681 if postIndex < 0 { 7682 return ErrInvalidLength 7683 } 7684 if postIndex > l { 7685 return io.ErrUnexpectedEOF 7686 } 7687 m.PrimaryKeyValues = append(m.PrimaryKeyValues, &Row{}) 7688 if err := m.PrimaryKeyValues[len(m.PrimaryKeyValues)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 7689 return err 7690 } 7691 iNdEx = postIndex 7692 case 5: 7693 if wireType != 2 { 7694 return fmt.Errorf("proto: wrong wireType = %d for field Sql", wireType) 7695 } 7696 var byteLen int 7697 for shift := uint(0); ; shift += 7 { 7698 if shift >= 64 { 7699 return ErrIntOverflow 7700 } 7701 if iNdEx >= l { 7702 return io.ErrUnexpectedEOF 7703 } 7704 b := dAtA[iNdEx] 7705 iNdEx++ 7706 byteLen |= int(b&0x7F) << shift 7707 if b < 0x80 { 7708 break 7709 } 7710 } 7711 if byteLen < 0 { 7712 return ErrInvalidLength 7713 } 7714 postIndex := iNdEx + byteLen 7715 if postIndex < 0 { 7716 return ErrInvalidLength 7717 } 7718 if postIndex > l { 7719 return io.ErrUnexpectedEOF 7720 } 7721 m.Sql = append(m.Sql[:0], dAtA[iNdEx:postIndex]...) 7722 if m.Sql == nil { 7723 m.Sql = []byte{} 7724 } 7725 iNdEx = postIndex 7726 default: 7727 iNdEx = preIndex 7728 skippy, err := skip(dAtA[iNdEx:]) 7729 if err != nil { 7730 return err 7731 } 7732 if (skippy < 0) || (iNdEx+skippy) < 0 { 7733 return ErrInvalidLength 7734 } 7735 if (iNdEx + skippy) > l { 7736 return io.ErrUnexpectedEOF 7737 } 7738 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 7739 iNdEx += skippy 7740 } 7741 } 7742 7743 if iNdEx > l { 7744 return io.ErrUnexpectedEOF 7745 } 7746 return nil 7747 } 7748 func (m *StreamEvent) UnmarshalVT(dAtA []byte) error { 7749 l := len(dAtA) 7750 iNdEx := 0 7751 for iNdEx < l { 7752 preIndex := iNdEx 7753 var wire uint64 7754 for shift := uint(0); ; shift += 7 { 7755 if shift >= 64 { 7756 return ErrIntOverflow 7757 } 7758 if iNdEx >= l { 7759 return io.ErrUnexpectedEOF 7760 } 7761 b := dAtA[iNdEx] 7762 iNdEx++ 7763 wire |= uint64(b&0x7F) << shift 7764 if b < 0x80 { 7765 break 7766 } 7767 } 7768 fieldNum := int32(wire >> 3) 7769 wireType := int(wire & 0x7) 7770 if wireType == 4 { 7771 return fmt.Errorf("proto: StreamEvent: wiretype end group for non-group") 7772 } 7773 if fieldNum <= 0 { 7774 return fmt.Errorf("proto: StreamEvent: illegal tag %d (wire type %d)", fieldNum, wire) 7775 } 7776 switch fieldNum { 7777 case 1: 7778 if wireType != 2 { 7779 return fmt.Errorf("proto: wrong wireType = %d for field Statements", wireType) 7780 } 7781 var msglen int 7782 for shift := uint(0); ; shift += 7 { 7783 if shift >= 64 { 7784 return ErrIntOverflow 7785 } 7786 if iNdEx >= l { 7787 return io.ErrUnexpectedEOF 7788 } 7789 b := dAtA[iNdEx] 7790 iNdEx++ 7791 msglen |= int(b&0x7F) << shift 7792 if b < 0x80 { 7793 break 7794 } 7795 } 7796 if msglen < 0 { 7797 return ErrInvalidLength 7798 } 7799 postIndex := iNdEx + msglen 7800 if postIndex < 0 { 7801 return ErrInvalidLength 7802 } 7803 if postIndex > l { 7804 return io.ErrUnexpectedEOF 7805 } 7806 m.Statements = append(m.Statements, &StreamEvent_Statement{}) 7807 if err := m.Statements[len(m.Statements)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 7808 return err 7809 } 7810 iNdEx = postIndex 7811 case 2: 7812 if wireType != 2 { 7813 return fmt.Errorf("proto: wrong wireType = %d for field EventToken", wireType) 7814 } 7815 var msglen int 7816 for shift := uint(0); ; shift += 7 { 7817 if shift >= 64 { 7818 return ErrIntOverflow 7819 } 7820 if iNdEx >= l { 7821 return io.ErrUnexpectedEOF 7822 } 7823 b := dAtA[iNdEx] 7824 iNdEx++ 7825 msglen |= int(b&0x7F) << shift 7826 if b < 0x80 { 7827 break 7828 } 7829 } 7830 if msglen < 0 { 7831 return ErrInvalidLength 7832 } 7833 postIndex := iNdEx + msglen 7834 if postIndex < 0 { 7835 return ErrInvalidLength 7836 } 7837 if postIndex > l { 7838 return io.ErrUnexpectedEOF 7839 } 7840 if m.EventToken == nil { 7841 m.EventToken = &EventToken{} 7842 } 7843 if err := m.EventToken.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 7844 return err 7845 } 7846 iNdEx = postIndex 7847 default: 7848 iNdEx = preIndex 7849 skippy, err := skip(dAtA[iNdEx:]) 7850 if err != nil { 7851 return err 7852 } 7853 if (skippy < 0) || (iNdEx+skippy) < 0 { 7854 return ErrInvalidLength 7855 } 7856 if (iNdEx + skippy) > l { 7857 return io.ErrUnexpectedEOF 7858 } 7859 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 7860 iNdEx += skippy 7861 } 7862 } 7863 7864 if iNdEx > l { 7865 return io.ErrUnexpectedEOF 7866 } 7867 return nil 7868 } 7869 func (m *ExecuteRequest) UnmarshalVT(dAtA []byte) error { 7870 l := len(dAtA) 7871 iNdEx := 0 7872 for iNdEx < l { 7873 preIndex := iNdEx 7874 var wire uint64 7875 for shift := uint(0); ; shift += 7 { 7876 if shift >= 64 { 7877 return ErrIntOverflow 7878 } 7879 if iNdEx >= l { 7880 return io.ErrUnexpectedEOF 7881 } 7882 b := dAtA[iNdEx] 7883 iNdEx++ 7884 wire |= uint64(b&0x7F) << shift 7885 if b < 0x80 { 7886 break 7887 } 7888 } 7889 fieldNum := int32(wire >> 3) 7890 wireType := int(wire & 0x7) 7891 if wireType == 4 { 7892 return fmt.Errorf("proto: ExecuteRequest: wiretype end group for non-group") 7893 } 7894 if fieldNum <= 0 { 7895 return fmt.Errorf("proto: ExecuteRequest: illegal tag %d (wire type %d)", fieldNum, wire) 7896 } 7897 switch fieldNum { 7898 case 1: 7899 if wireType != 2 { 7900 return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType) 7901 } 7902 var msglen int 7903 for shift := uint(0); ; shift += 7 { 7904 if shift >= 64 { 7905 return ErrIntOverflow 7906 } 7907 if iNdEx >= l { 7908 return io.ErrUnexpectedEOF 7909 } 7910 b := dAtA[iNdEx] 7911 iNdEx++ 7912 msglen |= int(b&0x7F) << shift 7913 if b < 0x80 { 7914 break 7915 } 7916 } 7917 if msglen < 0 { 7918 return ErrInvalidLength 7919 } 7920 postIndex := iNdEx + msglen 7921 if postIndex < 0 { 7922 return ErrInvalidLength 7923 } 7924 if postIndex > l { 7925 return io.ErrUnexpectedEOF 7926 } 7927 if m.EffectiveCallerId == nil { 7928 m.EffectiveCallerId = &vtrpc.CallerID{} 7929 } 7930 if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 7931 return err 7932 } 7933 iNdEx = postIndex 7934 case 2: 7935 if wireType != 2 { 7936 return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType) 7937 } 7938 var msglen int 7939 for shift := uint(0); ; shift += 7 { 7940 if shift >= 64 { 7941 return ErrIntOverflow 7942 } 7943 if iNdEx >= l { 7944 return io.ErrUnexpectedEOF 7945 } 7946 b := dAtA[iNdEx] 7947 iNdEx++ 7948 msglen |= int(b&0x7F) << shift 7949 if b < 0x80 { 7950 break 7951 } 7952 } 7953 if msglen < 0 { 7954 return ErrInvalidLength 7955 } 7956 postIndex := iNdEx + msglen 7957 if postIndex < 0 { 7958 return ErrInvalidLength 7959 } 7960 if postIndex > l { 7961 return io.ErrUnexpectedEOF 7962 } 7963 if m.ImmediateCallerId == nil { 7964 m.ImmediateCallerId = &VTGateCallerID{} 7965 } 7966 if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 7967 return err 7968 } 7969 iNdEx = postIndex 7970 case 3: 7971 if wireType != 2 { 7972 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 7973 } 7974 var msglen int 7975 for shift := uint(0); ; shift += 7 { 7976 if shift >= 64 { 7977 return ErrIntOverflow 7978 } 7979 if iNdEx >= l { 7980 return io.ErrUnexpectedEOF 7981 } 7982 b := dAtA[iNdEx] 7983 iNdEx++ 7984 msglen |= int(b&0x7F) << shift 7985 if b < 0x80 { 7986 break 7987 } 7988 } 7989 if msglen < 0 { 7990 return ErrInvalidLength 7991 } 7992 postIndex := iNdEx + msglen 7993 if postIndex < 0 { 7994 return ErrInvalidLength 7995 } 7996 if postIndex > l { 7997 return io.ErrUnexpectedEOF 7998 } 7999 if m.Target == nil { 8000 m.Target = &Target{} 8001 } 8002 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 8003 return err 8004 } 8005 iNdEx = postIndex 8006 case 4: 8007 if wireType != 2 { 8008 return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) 8009 } 8010 var msglen int 8011 for shift := uint(0); ; shift += 7 { 8012 if shift >= 64 { 8013 return ErrIntOverflow 8014 } 8015 if iNdEx >= l { 8016 return io.ErrUnexpectedEOF 8017 } 8018 b := dAtA[iNdEx] 8019 iNdEx++ 8020 msglen |= int(b&0x7F) << shift 8021 if b < 0x80 { 8022 break 8023 } 8024 } 8025 if msglen < 0 { 8026 return ErrInvalidLength 8027 } 8028 postIndex := iNdEx + msglen 8029 if postIndex < 0 { 8030 return ErrInvalidLength 8031 } 8032 if postIndex > l { 8033 return io.ErrUnexpectedEOF 8034 } 8035 if m.Query == nil { 8036 m.Query = &BoundQuery{} 8037 } 8038 if err := m.Query.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 8039 return err 8040 } 8041 iNdEx = postIndex 8042 case 5: 8043 if wireType != 0 { 8044 return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType) 8045 } 8046 m.TransactionId = 0 8047 for shift := uint(0); ; shift += 7 { 8048 if shift >= 64 { 8049 return ErrIntOverflow 8050 } 8051 if iNdEx >= l { 8052 return io.ErrUnexpectedEOF 8053 } 8054 b := dAtA[iNdEx] 8055 iNdEx++ 8056 m.TransactionId |= int64(b&0x7F) << shift 8057 if b < 0x80 { 8058 break 8059 } 8060 } 8061 case 6: 8062 if wireType != 2 { 8063 return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType) 8064 } 8065 var msglen int 8066 for shift := uint(0); ; shift += 7 { 8067 if shift >= 64 { 8068 return ErrIntOverflow 8069 } 8070 if iNdEx >= l { 8071 return io.ErrUnexpectedEOF 8072 } 8073 b := dAtA[iNdEx] 8074 iNdEx++ 8075 msglen |= int(b&0x7F) << shift 8076 if b < 0x80 { 8077 break 8078 } 8079 } 8080 if msglen < 0 { 8081 return ErrInvalidLength 8082 } 8083 postIndex := iNdEx + msglen 8084 if postIndex < 0 { 8085 return ErrInvalidLength 8086 } 8087 if postIndex > l { 8088 return io.ErrUnexpectedEOF 8089 } 8090 if m.Options == nil { 8091 m.Options = &ExecuteOptions{} 8092 } 8093 if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 8094 return err 8095 } 8096 iNdEx = postIndex 8097 case 7: 8098 if wireType != 0 { 8099 return fmt.Errorf("proto: wrong wireType = %d for field ReservedId", wireType) 8100 } 8101 m.ReservedId = 0 8102 for shift := uint(0); ; shift += 7 { 8103 if shift >= 64 { 8104 return ErrIntOverflow 8105 } 8106 if iNdEx >= l { 8107 return io.ErrUnexpectedEOF 8108 } 8109 b := dAtA[iNdEx] 8110 iNdEx++ 8111 m.ReservedId |= int64(b&0x7F) << shift 8112 if b < 0x80 { 8113 break 8114 } 8115 } 8116 default: 8117 iNdEx = preIndex 8118 skippy, err := skip(dAtA[iNdEx:]) 8119 if err != nil { 8120 return err 8121 } 8122 if (skippy < 0) || (iNdEx+skippy) < 0 { 8123 return ErrInvalidLength 8124 } 8125 if (iNdEx + skippy) > l { 8126 return io.ErrUnexpectedEOF 8127 } 8128 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 8129 iNdEx += skippy 8130 } 8131 } 8132 8133 if iNdEx > l { 8134 return io.ErrUnexpectedEOF 8135 } 8136 return nil 8137 } 8138 func (m *ExecuteResponse) UnmarshalVT(dAtA []byte) error { 8139 l := len(dAtA) 8140 iNdEx := 0 8141 for iNdEx < l { 8142 preIndex := iNdEx 8143 var wire uint64 8144 for shift := uint(0); ; shift += 7 { 8145 if shift >= 64 { 8146 return ErrIntOverflow 8147 } 8148 if iNdEx >= l { 8149 return io.ErrUnexpectedEOF 8150 } 8151 b := dAtA[iNdEx] 8152 iNdEx++ 8153 wire |= uint64(b&0x7F) << shift 8154 if b < 0x80 { 8155 break 8156 } 8157 } 8158 fieldNum := int32(wire >> 3) 8159 wireType := int(wire & 0x7) 8160 if wireType == 4 { 8161 return fmt.Errorf("proto: ExecuteResponse: wiretype end group for non-group") 8162 } 8163 if fieldNum <= 0 { 8164 return fmt.Errorf("proto: ExecuteResponse: illegal tag %d (wire type %d)", fieldNum, wire) 8165 } 8166 switch fieldNum { 8167 case 1: 8168 if wireType != 2 { 8169 return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) 8170 } 8171 var msglen int 8172 for shift := uint(0); ; shift += 7 { 8173 if shift >= 64 { 8174 return ErrIntOverflow 8175 } 8176 if iNdEx >= l { 8177 return io.ErrUnexpectedEOF 8178 } 8179 b := dAtA[iNdEx] 8180 iNdEx++ 8181 msglen |= int(b&0x7F) << shift 8182 if b < 0x80 { 8183 break 8184 } 8185 } 8186 if msglen < 0 { 8187 return ErrInvalidLength 8188 } 8189 postIndex := iNdEx + msglen 8190 if postIndex < 0 { 8191 return ErrInvalidLength 8192 } 8193 if postIndex > l { 8194 return io.ErrUnexpectedEOF 8195 } 8196 if m.Result == nil { 8197 m.Result = &QueryResult{} 8198 } 8199 if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 8200 return err 8201 } 8202 iNdEx = postIndex 8203 default: 8204 iNdEx = preIndex 8205 skippy, err := skip(dAtA[iNdEx:]) 8206 if err != nil { 8207 return err 8208 } 8209 if (skippy < 0) || (iNdEx+skippy) < 0 { 8210 return ErrInvalidLength 8211 } 8212 if (iNdEx + skippy) > l { 8213 return io.ErrUnexpectedEOF 8214 } 8215 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 8216 iNdEx += skippy 8217 } 8218 } 8219 8220 if iNdEx > l { 8221 return io.ErrUnexpectedEOF 8222 } 8223 return nil 8224 } 8225 func (m *ResultWithError) UnmarshalVT(dAtA []byte) error { 8226 l := len(dAtA) 8227 iNdEx := 0 8228 for iNdEx < l { 8229 preIndex := iNdEx 8230 var wire uint64 8231 for shift := uint(0); ; shift += 7 { 8232 if shift >= 64 { 8233 return ErrIntOverflow 8234 } 8235 if iNdEx >= l { 8236 return io.ErrUnexpectedEOF 8237 } 8238 b := dAtA[iNdEx] 8239 iNdEx++ 8240 wire |= uint64(b&0x7F) << shift 8241 if b < 0x80 { 8242 break 8243 } 8244 } 8245 fieldNum := int32(wire >> 3) 8246 wireType := int(wire & 0x7) 8247 if wireType == 4 { 8248 return fmt.Errorf("proto: ResultWithError: wiretype end group for non-group") 8249 } 8250 if fieldNum <= 0 { 8251 return fmt.Errorf("proto: ResultWithError: illegal tag %d (wire type %d)", fieldNum, wire) 8252 } 8253 switch fieldNum { 8254 case 1: 8255 if wireType != 2 { 8256 return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) 8257 } 8258 var msglen int 8259 for shift := uint(0); ; shift += 7 { 8260 if shift >= 64 { 8261 return ErrIntOverflow 8262 } 8263 if iNdEx >= l { 8264 return io.ErrUnexpectedEOF 8265 } 8266 b := dAtA[iNdEx] 8267 iNdEx++ 8268 msglen |= int(b&0x7F) << shift 8269 if b < 0x80 { 8270 break 8271 } 8272 } 8273 if msglen < 0 { 8274 return ErrInvalidLength 8275 } 8276 postIndex := iNdEx + msglen 8277 if postIndex < 0 { 8278 return ErrInvalidLength 8279 } 8280 if postIndex > l { 8281 return io.ErrUnexpectedEOF 8282 } 8283 if m.Error == nil { 8284 m.Error = &vtrpc.RPCError{} 8285 } 8286 if err := m.Error.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 8287 return err 8288 } 8289 iNdEx = postIndex 8290 case 2: 8291 if wireType != 2 { 8292 return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) 8293 } 8294 var msglen int 8295 for shift := uint(0); ; shift += 7 { 8296 if shift >= 64 { 8297 return ErrIntOverflow 8298 } 8299 if iNdEx >= l { 8300 return io.ErrUnexpectedEOF 8301 } 8302 b := dAtA[iNdEx] 8303 iNdEx++ 8304 msglen |= int(b&0x7F) << shift 8305 if b < 0x80 { 8306 break 8307 } 8308 } 8309 if msglen < 0 { 8310 return ErrInvalidLength 8311 } 8312 postIndex := iNdEx + msglen 8313 if postIndex < 0 { 8314 return ErrInvalidLength 8315 } 8316 if postIndex > l { 8317 return io.ErrUnexpectedEOF 8318 } 8319 if m.Result == nil { 8320 m.Result = &QueryResult{} 8321 } 8322 if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 8323 return err 8324 } 8325 iNdEx = postIndex 8326 default: 8327 iNdEx = preIndex 8328 skippy, err := skip(dAtA[iNdEx:]) 8329 if err != nil { 8330 return err 8331 } 8332 if (skippy < 0) || (iNdEx+skippy) < 0 { 8333 return ErrInvalidLength 8334 } 8335 if (iNdEx + skippy) > l { 8336 return io.ErrUnexpectedEOF 8337 } 8338 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 8339 iNdEx += skippy 8340 } 8341 } 8342 8343 if iNdEx > l { 8344 return io.ErrUnexpectedEOF 8345 } 8346 return nil 8347 } 8348 func (m *StreamExecuteRequest) UnmarshalVT(dAtA []byte) error { 8349 l := len(dAtA) 8350 iNdEx := 0 8351 for iNdEx < l { 8352 preIndex := iNdEx 8353 var wire uint64 8354 for shift := uint(0); ; shift += 7 { 8355 if shift >= 64 { 8356 return ErrIntOverflow 8357 } 8358 if iNdEx >= l { 8359 return io.ErrUnexpectedEOF 8360 } 8361 b := dAtA[iNdEx] 8362 iNdEx++ 8363 wire |= uint64(b&0x7F) << shift 8364 if b < 0x80 { 8365 break 8366 } 8367 } 8368 fieldNum := int32(wire >> 3) 8369 wireType := int(wire & 0x7) 8370 if wireType == 4 { 8371 return fmt.Errorf("proto: StreamExecuteRequest: wiretype end group for non-group") 8372 } 8373 if fieldNum <= 0 { 8374 return fmt.Errorf("proto: StreamExecuteRequest: illegal tag %d (wire type %d)", fieldNum, wire) 8375 } 8376 switch fieldNum { 8377 case 1: 8378 if wireType != 2 { 8379 return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType) 8380 } 8381 var msglen int 8382 for shift := uint(0); ; shift += 7 { 8383 if shift >= 64 { 8384 return ErrIntOverflow 8385 } 8386 if iNdEx >= l { 8387 return io.ErrUnexpectedEOF 8388 } 8389 b := dAtA[iNdEx] 8390 iNdEx++ 8391 msglen |= int(b&0x7F) << shift 8392 if b < 0x80 { 8393 break 8394 } 8395 } 8396 if msglen < 0 { 8397 return ErrInvalidLength 8398 } 8399 postIndex := iNdEx + msglen 8400 if postIndex < 0 { 8401 return ErrInvalidLength 8402 } 8403 if postIndex > l { 8404 return io.ErrUnexpectedEOF 8405 } 8406 if m.EffectiveCallerId == nil { 8407 m.EffectiveCallerId = &vtrpc.CallerID{} 8408 } 8409 if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 8410 return err 8411 } 8412 iNdEx = postIndex 8413 case 2: 8414 if wireType != 2 { 8415 return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType) 8416 } 8417 var msglen int 8418 for shift := uint(0); ; shift += 7 { 8419 if shift >= 64 { 8420 return ErrIntOverflow 8421 } 8422 if iNdEx >= l { 8423 return io.ErrUnexpectedEOF 8424 } 8425 b := dAtA[iNdEx] 8426 iNdEx++ 8427 msglen |= int(b&0x7F) << shift 8428 if b < 0x80 { 8429 break 8430 } 8431 } 8432 if msglen < 0 { 8433 return ErrInvalidLength 8434 } 8435 postIndex := iNdEx + msglen 8436 if postIndex < 0 { 8437 return ErrInvalidLength 8438 } 8439 if postIndex > l { 8440 return io.ErrUnexpectedEOF 8441 } 8442 if m.ImmediateCallerId == nil { 8443 m.ImmediateCallerId = &VTGateCallerID{} 8444 } 8445 if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 8446 return err 8447 } 8448 iNdEx = postIndex 8449 case 3: 8450 if wireType != 2 { 8451 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 8452 } 8453 var msglen int 8454 for shift := uint(0); ; shift += 7 { 8455 if shift >= 64 { 8456 return ErrIntOverflow 8457 } 8458 if iNdEx >= l { 8459 return io.ErrUnexpectedEOF 8460 } 8461 b := dAtA[iNdEx] 8462 iNdEx++ 8463 msglen |= int(b&0x7F) << shift 8464 if b < 0x80 { 8465 break 8466 } 8467 } 8468 if msglen < 0 { 8469 return ErrInvalidLength 8470 } 8471 postIndex := iNdEx + msglen 8472 if postIndex < 0 { 8473 return ErrInvalidLength 8474 } 8475 if postIndex > l { 8476 return io.ErrUnexpectedEOF 8477 } 8478 if m.Target == nil { 8479 m.Target = &Target{} 8480 } 8481 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 8482 return err 8483 } 8484 iNdEx = postIndex 8485 case 4: 8486 if wireType != 2 { 8487 return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) 8488 } 8489 var msglen int 8490 for shift := uint(0); ; shift += 7 { 8491 if shift >= 64 { 8492 return ErrIntOverflow 8493 } 8494 if iNdEx >= l { 8495 return io.ErrUnexpectedEOF 8496 } 8497 b := dAtA[iNdEx] 8498 iNdEx++ 8499 msglen |= int(b&0x7F) << shift 8500 if b < 0x80 { 8501 break 8502 } 8503 } 8504 if msglen < 0 { 8505 return ErrInvalidLength 8506 } 8507 postIndex := iNdEx + msglen 8508 if postIndex < 0 { 8509 return ErrInvalidLength 8510 } 8511 if postIndex > l { 8512 return io.ErrUnexpectedEOF 8513 } 8514 if m.Query == nil { 8515 m.Query = &BoundQuery{} 8516 } 8517 if err := m.Query.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 8518 return err 8519 } 8520 iNdEx = postIndex 8521 case 5: 8522 if wireType != 2 { 8523 return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType) 8524 } 8525 var msglen int 8526 for shift := uint(0); ; shift += 7 { 8527 if shift >= 64 { 8528 return ErrIntOverflow 8529 } 8530 if iNdEx >= l { 8531 return io.ErrUnexpectedEOF 8532 } 8533 b := dAtA[iNdEx] 8534 iNdEx++ 8535 msglen |= int(b&0x7F) << shift 8536 if b < 0x80 { 8537 break 8538 } 8539 } 8540 if msglen < 0 { 8541 return ErrInvalidLength 8542 } 8543 postIndex := iNdEx + msglen 8544 if postIndex < 0 { 8545 return ErrInvalidLength 8546 } 8547 if postIndex > l { 8548 return io.ErrUnexpectedEOF 8549 } 8550 if m.Options == nil { 8551 m.Options = &ExecuteOptions{} 8552 } 8553 if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 8554 return err 8555 } 8556 iNdEx = postIndex 8557 case 6: 8558 if wireType != 0 { 8559 return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType) 8560 } 8561 m.TransactionId = 0 8562 for shift := uint(0); ; shift += 7 { 8563 if shift >= 64 { 8564 return ErrIntOverflow 8565 } 8566 if iNdEx >= l { 8567 return io.ErrUnexpectedEOF 8568 } 8569 b := dAtA[iNdEx] 8570 iNdEx++ 8571 m.TransactionId |= int64(b&0x7F) << shift 8572 if b < 0x80 { 8573 break 8574 } 8575 } 8576 case 7: 8577 if wireType != 0 { 8578 return fmt.Errorf("proto: wrong wireType = %d for field ReservedId", wireType) 8579 } 8580 m.ReservedId = 0 8581 for shift := uint(0); ; shift += 7 { 8582 if shift >= 64 { 8583 return ErrIntOverflow 8584 } 8585 if iNdEx >= l { 8586 return io.ErrUnexpectedEOF 8587 } 8588 b := dAtA[iNdEx] 8589 iNdEx++ 8590 m.ReservedId |= int64(b&0x7F) << shift 8591 if b < 0x80 { 8592 break 8593 } 8594 } 8595 default: 8596 iNdEx = preIndex 8597 skippy, err := skip(dAtA[iNdEx:]) 8598 if err != nil { 8599 return err 8600 } 8601 if (skippy < 0) || (iNdEx+skippy) < 0 { 8602 return ErrInvalidLength 8603 } 8604 if (iNdEx + skippy) > l { 8605 return io.ErrUnexpectedEOF 8606 } 8607 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 8608 iNdEx += skippy 8609 } 8610 } 8611 8612 if iNdEx > l { 8613 return io.ErrUnexpectedEOF 8614 } 8615 return nil 8616 } 8617 func (m *StreamExecuteResponse) UnmarshalVT(dAtA []byte) error { 8618 l := len(dAtA) 8619 iNdEx := 0 8620 for iNdEx < l { 8621 preIndex := iNdEx 8622 var wire uint64 8623 for shift := uint(0); ; shift += 7 { 8624 if shift >= 64 { 8625 return ErrIntOverflow 8626 } 8627 if iNdEx >= l { 8628 return io.ErrUnexpectedEOF 8629 } 8630 b := dAtA[iNdEx] 8631 iNdEx++ 8632 wire |= uint64(b&0x7F) << shift 8633 if b < 0x80 { 8634 break 8635 } 8636 } 8637 fieldNum := int32(wire >> 3) 8638 wireType := int(wire & 0x7) 8639 if wireType == 4 { 8640 return fmt.Errorf("proto: StreamExecuteResponse: wiretype end group for non-group") 8641 } 8642 if fieldNum <= 0 { 8643 return fmt.Errorf("proto: StreamExecuteResponse: illegal tag %d (wire type %d)", fieldNum, wire) 8644 } 8645 switch fieldNum { 8646 case 1: 8647 if wireType != 2 { 8648 return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) 8649 } 8650 var msglen int 8651 for shift := uint(0); ; shift += 7 { 8652 if shift >= 64 { 8653 return ErrIntOverflow 8654 } 8655 if iNdEx >= l { 8656 return io.ErrUnexpectedEOF 8657 } 8658 b := dAtA[iNdEx] 8659 iNdEx++ 8660 msglen |= int(b&0x7F) << shift 8661 if b < 0x80 { 8662 break 8663 } 8664 } 8665 if msglen < 0 { 8666 return ErrInvalidLength 8667 } 8668 postIndex := iNdEx + msglen 8669 if postIndex < 0 { 8670 return ErrInvalidLength 8671 } 8672 if postIndex > l { 8673 return io.ErrUnexpectedEOF 8674 } 8675 if m.Result == nil { 8676 m.Result = &QueryResult{} 8677 } 8678 if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 8679 return err 8680 } 8681 iNdEx = postIndex 8682 default: 8683 iNdEx = preIndex 8684 skippy, err := skip(dAtA[iNdEx:]) 8685 if err != nil { 8686 return err 8687 } 8688 if (skippy < 0) || (iNdEx+skippy) < 0 { 8689 return ErrInvalidLength 8690 } 8691 if (iNdEx + skippy) > l { 8692 return io.ErrUnexpectedEOF 8693 } 8694 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 8695 iNdEx += skippy 8696 } 8697 } 8698 8699 if iNdEx > l { 8700 return io.ErrUnexpectedEOF 8701 } 8702 return nil 8703 } 8704 func (m *BeginRequest) UnmarshalVT(dAtA []byte) error { 8705 l := len(dAtA) 8706 iNdEx := 0 8707 for iNdEx < l { 8708 preIndex := iNdEx 8709 var wire uint64 8710 for shift := uint(0); ; shift += 7 { 8711 if shift >= 64 { 8712 return ErrIntOverflow 8713 } 8714 if iNdEx >= l { 8715 return io.ErrUnexpectedEOF 8716 } 8717 b := dAtA[iNdEx] 8718 iNdEx++ 8719 wire |= uint64(b&0x7F) << shift 8720 if b < 0x80 { 8721 break 8722 } 8723 } 8724 fieldNum := int32(wire >> 3) 8725 wireType := int(wire & 0x7) 8726 if wireType == 4 { 8727 return fmt.Errorf("proto: BeginRequest: wiretype end group for non-group") 8728 } 8729 if fieldNum <= 0 { 8730 return fmt.Errorf("proto: BeginRequest: illegal tag %d (wire type %d)", fieldNum, wire) 8731 } 8732 switch fieldNum { 8733 case 1: 8734 if wireType != 2 { 8735 return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType) 8736 } 8737 var msglen int 8738 for shift := uint(0); ; shift += 7 { 8739 if shift >= 64 { 8740 return ErrIntOverflow 8741 } 8742 if iNdEx >= l { 8743 return io.ErrUnexpectedEOF 8744 } 8745 b := dAtA[iNdEx] 8746 iNdEx++ 8747 msglen |= int(b&0x7F) << shift 8748 if b < 0x80 { 8749 break 8750 } 8751 } 8752 if msglen < 0 { 8753 return ErrInvalidLength 8754 } 8755 postIndex := iNdEx + msglen 8756 if postIndex < 0 { 8757 return ErrInvalidLength 8758 } 8759 if postIndex > l { 8760 return io.ErrUnexpectedEOF 8761 } 8762 if m.EffectiveCallerId == nil { 8763 m.EffectiveCallerId = &vtrpc.CallerID{} 8764 } 8765 if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 8766 return err 8767 } 8768 iNdEx = postIndex 8769 case 2: 8770 if wireType != 2 { 8771 return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType) 8772 } 8773 var msglen int 8774 for shift := uint(0); ; shift += 7 { 8775 if shift >= 64 { 8776 return ErrIntOverflow 8777 } 8778 if iNdEx >= l { 8779 return io.ErrUnexpectedEOF 8780 } 8781 b := dAtA[iNdEx] 8782 iNdEx++ 8783 msglen |= int(b&0x7F) << shift 8784 if b < 0x80 { 8785 break 8786 } 8787 } 8788 if msglen < 0 { 8789 return ErrInvalidLength 8790 } 8791 postIndex := iNdEx + msglen 8792 if postIndex < 0 { 8793 return ErrInvalidLength 8794 } 8795 if postIndex > l { 8796 return io.ErrUnexpectedEOF 8797 } 8798 if m.ImmediateCallerId == nil { 8799 m.ImmediateCallerId = &VTGateCallerID{} 8800 } 8801 if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 8802 return err 8803 } 8804 iNdEx = postIndex 8805 case 3: 8806 if wireType != 2 { 8807 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 8808 } 8809 var msglen int 8810 for shift := uint(0); ; shift += 7 { 8811 if shift >= 64 { 8812 return ErrIntOverflow 8813 } 8814 if iNdEx >= l { 8815 return io.ErrUnexpectedEOF 8816 } 8817 b := dAtA[iNdEx] 8818 iNdEx++ 8819 msglen |= int(b&0x7F) << shift 8820 if b < 0x80 { 8821 break 8822 } 8823 } 8824 if msglen < 0 { 8825 return ErrInvalidLength 8826 } 8827 postIndex := iNdEx + msglen 8828 if postIndex < 0 { 8829 return ErrInvalidLength 8830 } 8831 if postIndex > l { 8832 return io.ErrUnexpectedEOF 8833 } 8834 if m.Target == nil { 8835 m.Target = &Target{} 8836 } 8837 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 8838 return err 8839 } 8840 iNdEx = postIndex 8841 case 4: 8842 if wireType != 2 { 8843 return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType) 8844 } 8845 var msglen int 8846 for shift := uint(0); ; shift += 7 { 8847 if shift >= 64 { 8848 return ErrIntOverflow 8849 } 8850 if iNdEx >= l { 8851 return io.ErrUnexpectedEOF 8852 } 8853 b := dAtA[iNdEx] 8854 iNdEx++ 8855 msglen |= int(b&0x7F) << shift 8856 if b < 0x80 { 8857 break 8858 } 8859 } 8860 if msglen < 0 { 8861 return ErrInvalidLength 8862 } 8863 postIndex := iNdEx + msglen 8864 if postIndex < 0 { 8865 return ErrInvalidLength 8866 } 8867 if postIndex > l { 8868 return io.ErrUnexpectedEOF 8869 } 8870 if m.Options == nil { 8871 m.Options = &ExecuteOptions{} 8872 } 8873 if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 8874 return err 8875 } 8876 iNdEx = postIndex 8877 default: 8878 iNdEx = preIndex 8879 skippy, err := skip(dAtA[iNdEx:]) 8880 if err != nil { 8881 return err 8882 } 8883 if (skippy < 0) || (iNdEx+skippy) < 0 { 8884 return ErrInvalidLength 8885 } 8886 if (iNdEx + skippy) > l { 8887 return io.ErrUnexpectedEOF 8888 } 8889 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 8890 iNdEx += skippy 8891 } 8892 } 8893 8894 if iNdEx > l { 8895 return io.ErrUnexpectedEOF 8896 } 8897 return nil 8898 } 8899 func (m *BeginResponse) UnmarshalVT(dAtA []byte) error { 8900 l := len(dAtA) 8901 iNdEx := 0 8902 for iNdEx < l { 8903 preIndex := iNdEx 8904 var wire uint64 8905 for shift := uint(0); ; shift += 7 { 8906 if shift >= 64 { 8907 return ErrIntOverflow 8908 } 8909 if iNdEx >= l { 8910 return io.ErrUnexpectedEOF 8911 } 8912 b := dAtA[iNdEx] 8913 iNdEx++ 8914 wire |= uint64(b&0x7F) << shift 8915 if b < 0x80 { 8916 break 8917 } 8918 } 8919 fieldNum := int32(wire >> 3) 8920 wireType := int(wire & 0x7) 8921 if wireType == 4 { 8922 return fmt.Errorf("proto: BeginResponse: wiretype end group for non-group") 8923 } 8924 if fieldNum <= 0 { 8925 return fmt.Errorf("proto: BeginResponse: illegal tag %d (wire type %d)", fieldNum, wire) 8926 } 8927 switch fieldNum { 8928 case 1: 8929 if wireType != 0 { 8930 return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType) 8931 } 8932 m.TransactionId = 0 8933 for shift := uint(0); ; shift += 7 { 8934 if shift >= 64 { 8935 return ErrIntOverflow 8936 } 8937 if iNdEx >= l { 8938 return io.ErrUnexpectedEOF 8939 } 8940 b := dAtA[iNdEx] 8941 iNdEx++ 8942 m.TransactionId |= int64(b&0x7F) << shift 8943 if b < 0x80 { 8944 break 8945 } 8946 } 8947 case 2: 8948 if wireType != 2 { 8949 return fmt.Errorf("proto: wrong wireType = %d for field TabletAlias", wireType) 8950 } 8951 var msglen int 8952 for shift := uint(0); ; shift += 7 { 8953 if shift >= 64 { 8954 return ErrIntOverflow 8955 } 8956 if iNdEx >= l { 8957 return io.ErrUnexpectedEOF 8958 } 8959 b := dAtA[iNdEx] 8960 iNdEx++ 8961 msglen |= int(b&0x7F) << shift 8962 if b < 0x80 { 8963 break 8964 } 8965 } 8966 if msglen < 0 { 8967 return ErrInvalidLength 8968 } 8969 postIndex := iNdEx + msglen 8970 if postIndex < 0 { 8971 return ErrInvalidLength 8972 } 8973 if postIndex > l { 8974 return io.ErrUnexpectedEOF 8975 } 8976 if m.TabletAlias == nil { 8977 m.TabletAlias = &topodata.TabletAlias{} 8978 } 8979 if err := m.TabletAlias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 8980 return err 8981 } 8982 iNdEx = postIndex 8983 default: 8984 iNdEx = preIndex 8985 skippy, err := skip(dAtA[iNdEx:]) 8986 if err != nil { 8987 return err 8988 } 8989 if (skippy < 0) || (iNdEx+skippy) < 0 { 8990 return ErrInvalidLength 8991 } 8992 if (iNdEx + skippy) > l { 8993 return io.ErrUnexpectedEOF 8994 } 8995 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 8996 iNdEx += skippy 8997 } 8998 } 8999 9000 if iNdEx > l { 9001 return io.ErrUnexpectedEOF 9002 } 9003 return nil 9004 } 9005 func (m *CommitRequest) UnmarshalVT(dAtA []byte) error { 9006 l := len(dAtA) 9007 iNdEx := 0 9008 for iNdEx < l { 9009 preIndex := iNdEx 9010 var wire uint64 9011 for shift := uint(0); ; shift += 7 { 9012 if shift >= 64 { 9013 return ErrIntOverflow 9014 } 9015 if iNdEx >= l { 9016 return io.ErrUnexpectedEOF 9017 } 9018 b := dAtA[iNdEx] 9019 iNdEx++ 9020 wire |= uint64(b&0x7F) << shift 9021 if b < 0x80 { 9022 break 9023 } 9024 } 9025 fieldNum := int32(wire >> 3) 9026 wireType := int(wire & 0x7) 9027 if wireType == 4 { 9028 return fmt.Errorf("proto: CommitRequest: wiretype end group for non-group") 9029 } 9030 if fieldNum <= 0 { 9031 return fmt.Errorf("proto: CommitRequest: illegal tag %d (wire type %d)", fieldNum, wire) 9032 } 9033 switch fieldNum { 9034 case 1: 9035 if wireType != 2 { 9036 return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType) 9037 } 9038 var msglen int 9039 for shift := uint(0); ; shift += 7 { 9040 if shift >= 64 { 9041 return ErrIntOverflow 9042 } 9043 if iNdEx >= l { 9044 return io.ErrUnexpectedEOF 9045 } 9046 b := dAtA[iNdEx] 9047 iNdEx++ 9048 msglen |= int(b&0x7F) << shift 9049 if b < 0x80 { 9050 break 9051 } 9052 } 9053 if msglen < 0 { 9054 return ErrInvalidLength 9055 } 9056 postIndex := iNdEx + msglen 9057 if postIndex < 0 { 9058 return ErrInvalidLength 9059 } 9060 if postIndex > l { 9061 return io.ErrUnexpectedEOF 9062 } 9063 if m.EffectiveCallerId == nil { 9064 m.EffectiveCallerId = &vtrpc.CallerID{} 9065 } 9066 if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 9067 return err 9068 } 9069 iNdEx = postIndex 9070 case 2: 9071 if wireType != 2 { 9072 return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType) 9073 } 9074 var msglen int 9075 for shift := uint(0); ; shift += 7 { 9076 if shift >= 64 { 9077 return ErrIntOverflow 9078 } 9079 if iNdEx >= l { 9080 return io.ErrUnexpectedEOF 9081 } 9082 b := dAtA[iNdEx] 9083 iNdEx++ 9084 msglen |= int(b&0x7F) << shift 9085 if b < 0x80 { 9086 break 9087 } 9088 } 9089 if msglen < 0 { 9090 return ErrInvalidLength 9091 } 9092 postIndex := iNdEx + msglen 9093 if postIndex < 0 { 9094 return ErrInvalidLength 9095 } 9096 if postIndex > l { 9097 return io.ErrUnexpectedEOF 9098 } 9099 if m.ImmediateCallerId == nil { 9100 m.ImmediateCallerId = &VTGateCallerID{} 9101 } 9102 if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 9103 return err 9104 } 9105 iNdEx = postIndex 9106 case 3: 9107 if wireType != 2 { 9108 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 9109 } 9110 var msglen int 9111 for shift := uint(0); ; shift += 7 { 9112 if shift >= 64 { 9113 return ErrIntOverflow 9114 } 9115 if iNdEx >= l { 9116 return io.ErrUnexpectedEOF 9117 } 9118 b := dAtA[iNdEx] 9119 iNdEx++ 9120 msglen |= int(b&0x7F) << shift 9121 if b < 0x80 { 9122 break 9123 } 9124 } 9125 if msglen < 0 { 9126 return ErrInvalidLength 9127 } 9128 postIndex := iNdEx + msglen 9129 if postIndex < 0 { 9130 return ErrInvalidLength 9131 } 9132 if postIndex > l { 9133 return io.ErrUnexpectedEOF 9134 } 9135 if m.Target == nil { 9136 m.Target = &Target{} 9137 } 9138 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 9139 return err 9140 } 9141 iNdEx = postIndex 9142 case 4: 9143 if wireType != 0 { 9144 return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType) 9145 } 9146 m.TransactionId = 0 9147 for shift := uint(0); ; shift += 7 { 9148 if shift >= 64 { 9149 return ErrIntOverflow 9150 } 9151 if iNdEx >= l { 9152 return io.ErrUnexpectedEOF 9153 } 9154 b := dAtA[iNdEx] 9155 iNdEx++ 9156 m.TransactionId |= int64(b&0x7F) << shift 9157 if b < 0x80 { 9158 break 9159 } 9160 } 9161 default: 9162 iNdEx = preIndex 9163 skippy, err := skip(dAtA[iNdEx:]) 9164 if err != nil { 9165 return err 9166 } 9167 if (skippy < 0) || (iNdEx+skippy) < 0 { 9168 return ErrInvalidLength 9169 } 9170 if (iNdEx + skippy) > l { 9171 return io.ErrUnexpectedEOF 9172 } 9173 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 9174 iNdEx += skippy 9175 } 9176 } 9177 9178 if iNdEx > l { 9179 return io.ErrUnexpectedEOF 9180 } 9181 return nil 9182 } 9183 func (m *CommitResponse) UnmarshalVT(dAtA []byte) error { 9184 l := len(dAtA) 9185 iNdEx := 0 9186 for iNdEx < l { 9187 preIndex := iNdEx 9188 var wire uint64 9189 for shift := uint(0); ; shift += 7 { 9190 if shift >= 64 { 9191 return ErrIntOverflow 9192 } 9193 if iNdEx >= l { 9194 return io.ErrUnexpectedEOF 9195 } 9196 b := dAtA[iNdEx] 9197 iNdEx++ 9198 wire |= uint64(b&0x7F) << shift 9199 if b < 0x80 { 9200 break 9201 } 9202 } 9203 fieldNum := int32(wire >> 3) 9204 wireType := int(wire & 0x7) 9205 if wireType == 4 { 9206 return fmt.Errorf("proto: CommitResponse: wiretype end group for non-group") 9207 } 9208 if fieldNum <= 0 { 9209 return fmt.Errorf("proto: CommitResponse: illegal tag %d (wire type %d)", fieldNum, wire) 9210 } 9211 switch fieldNum { 9212 case 1: 9213 if wireType != 0 { 9214 return fmt.Errorf("proto: wrong wireType = %d for field ReservedId", wireType) 9215 } 9216 m.ReservedId = 0 9217 for shift := uint(0); ; shift += 7 { 9218 if shift >= 64 { 9219 return ErrIntOverflow 9220 } 9221 if iNdEx >= l { 9222 return io.ErrUnexpectedEOF 9223 } 9224 b := dAtA[iNdEx] 9225 iNdEx++ 9226 m.ReservedId |= int64(b&0x7F) << shift 9227 if b < 0x80 { 9228 break 9229 } 9230 } 9231 default: 9232 iNdEx = preIndex 9233 skippy, err := skip(dAtA[iNdEx:]) 9234 if err != nil { 9235 return err 9236 } 9237 if (skippy < 0) || (iNdEx+skippy) < 0 { 9238 return ErrInvalidLength 9239 } 9240 if (iNdEx + skippy) > l { 9241 return io.ErrUnexpectedEOF 9242 } 9243 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 9244 iNdEx += skippy 9245 } 9246 } 9247 9248 if iNdEx > l { 9249 return io.ErrUnexpectedEOF 9250 } 9251 return nil 9252 } 9253 func (m *RollbackRequest) UnmarshalVT(dAtA []byte) error { 9254 l := len(dAtA) 9255 iNdEx := 0 9256 for iNdEx < l { 9257 preIndex := iNdEx 9258 var wire uint64 9259 for shift := uint(0); ; shift += 7 { 9260 if shift >= 64 { 9261 return ErrIntOverflow 9262 } 9263 if iNdEx >= l { 9264 return io.ErrUnexpectedEOF 9265 } 9266 b := dAtA[iNdEx] 9267 iNdEx++ 9268 wire |= uint64(b&0x7F) << shift 9269 if b < 0x80 { 9270 break 9271 } 9272 } 9273 fieldNum := int32(wire >> 3) 9274 wireType := int(wire & 0x7) 9275 if wireType == 4 { 9276 return fmt.Errorf("proto: RollbackRequest: wiretype end group for non-group") 9277 } 9278 if fieldNum <= 0 { 9279 return fmt.Errorf("proto: RollbackRequest: illegal tag %d (wire type %d)", fieldNum, wire) 9280 } 9281 switch fieldNum { 9282 case 1: 9283 if wireType != 2 { 9284 return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType) 9285 } 9286 var msglen int 9287 for shift := uint(0); ; shift += 7 { 9288 if shift >= 64 { 9289 return ErrIntOverflow 9290 } 9291 if iNdEx >= l { 9292 return io.ErrUnexpectedEOF 9293 } 9294 b := dAtA[iNdEx] 9295 iNdEx++ 9296 msglen |= int(b&0x7F) << shift 9297 if b < 0x80 { 9298 break 9299 } 9300 } 9301 if msglen < 0 { 9302 return ErrInvalidLength 9303 } 9304 postIndex := iNdEx + msglen 9305 if postIndex < 0 { 9306 return ErrInvalidLength 9307 } 9308 if postIndex > l { 9309 return io.ErrUnexpectedEOF 9310 } 9311 if m.EffectiveCallerId == nil { 9312 m.EffectiveCallerId = &vtrpc.CallerID{} 9313 } 9314 if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 9315 return err 9316 } 9317 iNdEx = postIndex 9318 case 2: 9319 if wireType != 2 { 9320 return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType) 9321 } 9322 var msglen int 9323 for shift := uint(0); ; shift += 7 { 9324 if shift >= 64 { 9325 return ErrIntOverflow 9326 } 9327 if iNdEx >= l { 9328 return io.ErrUnexpectedEOF 9329 } 9330 b := dAtA[iNdEx] 9331 iNdEx++ 9332 msglen |= int(b&0x7F) << shift 9333 if b < 0x80 { 9334 break 9335 } 9336 } 9337 if msglen < 0 { 9338 return ErrInvalidLength 9339 } 9340 postIndex := iNdEx + msglen 9341 if postIndex < 0 { 9342 return ErrInvalidLength 9343 } 9344 if postIndex > l { 9345 return io.ErrUnexpectedEOF 9346 } 9347 if m.ImmediateCallerId == nil { 9348 m.ImmediateCallerId = &VTGateCallerID{} 9349 } 9350 if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 9351 return err 9352 } 9353 iNdEx = postIndex 9354 case 3: 9355 if wireType != 2 { 9356 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 9357 } 9358 var msglen int 9359 for shift := uint(0); ; shift += 7 { 9360 if shift >= 64 { 9361 return ErrIntOverflow 9362 } 9363 if iNdEx >= l { 9364 return io.ErrUnexpectedEOF 9365 } 9366 b := dAtA[iNdEx] 9367 iNdEx++ 9368 msglen |= int(b&0x7F) << shift 9369 if b < 0x80 { 9370 break 9371 } 9372 } 9373 if msglen < 0 { 9374 return ErrInvalidLength 9375 } 9376 postIndex := iNdEx + msglen 9377 if postIndex < 0 { 9378 return ErrInvalidLength 9379 } 9380 if postIndex > l { 9381 return io.ErrUnexpectedEOF 9382 } 9383 if m.Target == nil { 9384 m.Target = &Target{} 9385 } 9386 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 9387 return err 9388 } 9389 iNdEx = postIndex 9390 case 4: 9391 if wireType != 0 { 9392 return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType) 9393 } 9394 m.TransactionId = 0 9395 for shift := uint(0); ; shift += 7 { 9396 if shift >= 64 { 9397 return ErrIntOverflow 9398 } 9399 if iNdEx >= l { 9400 return io.ErrUnexpectedEOF 9401 } 9402 b := dAtA[iNdEx] 9403 iNdEx++ 9404 m.TransactionId |= int64(b&0x7F) << shift 9405 if b < 0x80 { 9406 break 9407 } 9408 } 9409 default: 9410 iNdEx = preIndex 9411 skippy, err := skip(dAtA[iNdEx:]) 9412 if err != nil { 9413 return err 9414 } 9415 if (skippy < 0) || (iNdEx+skippy) < 0 { 9416 return ErrInvalidLength 9417 } 9418 if (iNdEx + skippy) > l { 9419 return io.ErrUnexpectedEOF 9420 } 9421 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 9422 iNdEx += skippy 9423 } 9424 } 9425 9426 if iNdEx > l { 9427 return io.ErrUnexpectedEOF 9428 } 9429 return nil 9430 } 9431 func (m *RollbackResponse) UnmarshalVT(dAtA []byte) error { 9432 l := len(dAtA) 9433 iNdEx := 0 9434 for iNdEx < l { 9435 preIndex := iNdEx 9436 var wire uint64 9437 for shift := uint(0); ; shift += 7 { 9438 if shift >= 64 { 9439 return ErrIntOverflow 9440 } 9441 if iNdEx >= l { 9442 return io.ErrUnexpectedEOF 9443 } 9444 b := dAtA[iNdEx] 9445 iNdEx++ 9446 wire |= uint64(b&0x7F) << shift 9447 if b < 0x80 { 9448 break 9449 } 9450 } 9451 fieldNum := int32(wire >> 3) 9452 wireType := int(wire & 0x7) 9453 if wireType == 4 { 9454 return fmt.Errorf("proto: RollbackResponse: wiretype end group for non-group") 9455 } 9456 if fieldNum <= 0 { 9457 return fmt.Errorf("proto: RollbackResponse: illegal tag %d (wire type %d)", fieldNum, wire) 9458 } 9459 switch fieldNum { 9460 case 1: 9461 if wireType != 0 { 9462 return fmt.Errorf("proto: wrong wireType = %d for field ReservedId", wireType) 9463 } 9464 m.ReservedId = 0 9465 for shift := uint(0); ; shift += 7 { 9466 if shift >= 64 { 9467 return ErrIntOverflow 9468 } 9469 if iNdEx >= l { 9470 return io.ErrUnexpectedEOF 9471 } 9472 b := dAtA[iNdEx] 9473 iNdEx++ 9474 m.ReservedId |= int64(b&0x7F) << shift 9475 if b < 0x80 { 9476 break 9477 } 9478 } 9479 default: 9480 iNdEx = preIndex 9481 skippy, err := skip(dAtA[iNdEx:]) 9482 if err != nil { 9483 return err 9484 } 9485 if (skippy < 0) || (iNdEx+skippy) < 0 { 9486 return ErrInvalidLength 9487 } 9488 if (iNdEx + skippy) > l { 9489 return io.ErrUnexpectedEOF 9490 } 9491 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 9492 iNdEx += skippy 9493 } 9494 } 9495 9496 if iNdEx > l { 9497 return io.ErrUnexpectedEOF 9498 } 9499 return nil 9500 } 9501 func (m *PrepareRequest) UnmarshalVT(dAtA []byte) error { 9502 l := len(dAtA) 9503 iNdEx := 0 9504 for iNdEx < l { 9505 preIndex := iNdEx 9506 var wire uint64 9507 for shift := uint(0); ; shift += 7 { 9508 if shift >= 64 { 9509 return ErrIntOverflow 9510 } 9511 if iNdEx >= l { 9512 return io.ErrUnexpectedEOF 9513 } 9514 b := dAtA[iNdEx] 9515 iNdEx++ 9516 wire |= uint64(b&0x7F) << shift 9517 if b < 0x80 { 9518 break 9519 } 9520 } 9521 fieldNum := int32(wire >> 3) 9522 wireType := int(wire & 0x7) 9523 if wireType == 4 { 9524 return fmt.Errorf("proto: PrepareRequest: wiretype end group for non-group") 9525 } 9526 if fieldNum <= 0 { 9527 return fmt.Errorf("proto: PrepareRequest: illegal tag %d (wire type %d)", fieldNum, wire) 9528 } 9529 switch fieldNum { 9530 case 1: 9531 if wireType != 2 { 9532 return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType) 9533 } 9534 var msglen int 9535 for shift := uint(0); ; shift += 7 { 9536 if shift >= 64 { 9537 return ErrIntOverflow 9538 } 9539 if iNdEx >= l { 9540 return io.ErrUnexpectedEOF 9541 } 9542 b := dAtA[iNdEx] 9543 iNdEx++ 9544 msglen |= int(b&0x7F) << shift 9545 if b < 0x80 { 9546 break 9547 } 9548 } 9549 if msglen < 0 { 9550 return ErrInvalidLength 9551 } 9552 postIndex := iNdEx + msglen 9553 if postIndex < 0 { 9554 return ErrInvalidLength 9555 } 9556 if postIndex > l { 9557 return io.ErrUnexpectedEOF 9558 } 9559 if m.EffectiveCallerId == nil { 9560 m.EffectiveCallerId = &vtrpc.CallerID{} 9561 } 9562 if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 9563 return err 9564 } 9565 iNdEx = postIndex 9566 case 2: 9567 if wireType != 2 { 9568 return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType) 9569 } 9570 var msglen int 9571 for shift := uint(0); ; shift += 7 { 9572 if shift >= 64 { 9573 return ErrIntOverflow 9574 } 9575 if iNdEx >= l { 9576 return io.ErrUnexpectedEOF 9577 } 9578 b := dAtA[iNdEx] 9579 iNdEx++ 9580 msglen |= int(b&0x7F) << shift 9581 if b < 0x80 { 9582 break 9583 } 9584 } 9585 if msglen < 0 { 9586 return ErrInvalidLength 9587 } 9588 postIndex := iNdEx + msglen 9589 if postIndex < 0 { 9590 return ErrInvalidLength 9591 } 9592 if postIndex > l { 9593 return io.ErrUnexpectedEOF 9594 } 9595 if m.ImmediateCallerId == nil { 9596 m.ImmediateCallerId = &VTGateCallerID{} 9597 } 9598 if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 9599 return err 9600 } 9601 iNdEx = postIndex 9602 case 3: 9603 if wireType != 2 { 9604 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 9605 } 9606 var msglen int 9607 for shift := uint(0); ; shift += 7 { 9608 if shift >= 64 { 9609 return ErrIntOverflow 9610 } 9611 if iNdEx >= l { 9612 return io.ErrUnexpectedEOF 9613 } 9614 b := dAtA[iNdEx] 9615 iNdEx++ 9616 msglen |= int(b&0x7F) << shift 9617 if b < 0x80 { 9618 break 9619 } 9620 } 9621 if msglen < 0 { 9622 return ErrInvalidLength 9623 } 9624 postIndex := iNdEx + msglen 9625 if postIndex < 0 { 9626 return ErrInvalidLength 9627 } 9628 if postIndex > l { 9629 return io.ErrUnexpectedEOF 9630 } 9631 if m.Target == nil { 9632 m.Target = &Target{} 9633 } 9634 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 9635 return err 9636 } 9637 iNdEx = postIndex 9638 case 4: 9639 if wireType != 0 { 9640 return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType) 9641 } 9642 m.TransactionId = 0 9643 for shift := uint(0); ; shift += 7 { 9644 if shift >= 64 { 9645 return ErrIntOverflow 9646 } 9647 if iNdEx >= l { 9648 return io.ErrUnexpectedEOF 9649 } 9650 b := dAtA[iNdEx] 9651 iNdEx++ 9652 m.TransactionId |= int64(b&0x7F) << shift 9653 if b < 0x80 { 9654 break 9655 } 9656 } 9657 case 5: 9658 if wireType != 2 { 9659 return fmt.Errorf("proto: wrong wireType = %d for field Dtid", wireType) 9660 } 9661 var stringLen uint64 9662 for shift := uint(0); ; shift += 7 { 9663 if shift >= 64 { 9664 return ErrIntOverflow 9665 } 9666 if iNdEx >= l { 9667 return io.ErrUnexpectedEOF 9668 } 9669 b := dAtA[iNdEx] 9670 iNdEx++ 9671 stringLen |= uint64(b&0x7F) << shift 9672 if b < 0x80 { 9673 break 9674 } 9675 } 9676 intStringLen := int(stringLen) 9677 if intStringLen < 0 { 9678 return ErrInvalidLength 9679 } 9680 postIndex := iNdEx + intStringLen 9681 if postIndex < 0 { 9682 return ErrInvalidLength 9683 } 9684 if postIndex > l { 9685 return io.ErrUnexpectedEOF 9686 } 9687 m.Dtid = string(dAtA[iNdEx:postIndex]) 9688 iNdEx = postIndex 9689 default: 9690 iNdEx = preIndex 9691 skippy, err := skip(dAtA[iNdEx:]) 9692 if err != nil { 9693 return err 9694 } 9695 if (skippy < 0) || (iNdEx+skippy) < 0 { 9696 return ErrInvalidLength 9697 } 9698 if (iNdEx + skippy) > l { 9699 return io.ErrUnexpectedEOF 9700 } 9701 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 9702 iNdEx += skippy 9703 } 9704 } 9705 9706 if iNdEx > l { 9707 return io.ErrUnexpectedEOF 9708 } 9709 return nil 9710 } 9711 func (m *PrepareResponse) UnmarshalVT(dAtA []byte) error { 9712 l := len(dAtA) 9713 iNdEx := 0 9714 for iNdEx < l { 9715 preIndex := iNdEx 9716 var wire uint64 9717 for shift := uint(0); ; shift += 7 { 9718 if shift >= 64 { 9719 return ErrIntOverflow 9720 } 9721 if iNdEx >= l { 9722 return io.ErrUnexpectedEOF 9723 } 9724 b := dAtA[iNdEx] 9725 iNdEx++ 9726 wire |= uint64(b&0x7F) << shift 9727 if b < 0x80 { 9728 break 9729 } 9730 } 9731 fieldNum := int32(wire >> 3) 9732 wireType := int(wire & 0x7) 9733 if wireType == 4 { 9734 return fmt.Errorf("proto: PrepareResponse: wiretype end group for non-group") 9735 } 9736 if fieldNum <= 0 { 9737 return fmt.Errorf("proto: PrepareResponse: illegal tag %d (wire type %d)", fieldNum, wire) 9738 } 9739 switch fieldNum { 9740 default: 9741 iNdEx = preIndex 9742 skippy, err := skip(dAtA[iNdEx:]) 9743 if err != nil { 9744 return err 9745 } 9746 if (skippy < 0) || (iNdEx+skippy) < 0 { 9747 return ErrInvalidLength 9748 } 9749 if (iNdEx + skippy) > l { 9750 return io.ErrUnexpectedEOF 9751 } 9752 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 9753 iNdEx += skippy 9754 } 9755 } 9756 9757 if iNdEx > l { 9758 return io.ErrUnexpectedEOF 9759 } 9760 return nil 9761 } 9762 func (m *CommitPreparedRequest) UnmarshalVT(dAtA []byte) error { 9763 l := len(dAtA) 9764 iNdEx := 0 9765 for iNdEx < l { 9766 preIndex := iNdEx 9767 var wire uint64 9768 for shift := uint(0); ; shift += 7 { 9769 if shift >= 64 { 9770 return ErrIntOverflow 9771 } 9772 if iNdEx >= l { 9773 return io.ErrUnexpectedEOF 9774 } 9775 b := dAtA[iNdEx] 9776 iNdEx++ 9777 wire |= uint64(b&0x7F) << shift 9778 if b < 0x80 { 9779 break 9780 } 9781 } 9782 fieldNum := int32(wire >> 3) 9783 wireType := int(wire & 0x7) 9784 if wireType == 4 { 9785 return fmt.Errorf("proto: CommitPreparedRequest: wiretype end group for non-group") 9786 } 9787 if fieldNum <= 0 { 9788 return fmt.Errorf("proto: CommitPreparedRequest: illegal tag %d (wire type %d)", fieldNum, wire) 9789 } 9790 switch fieldNum { 9791 case 1: 9792 if wireType != 2 { 9793 return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType) 9794 } 9795 var msglen int 9796 for shift := uint(0); ; shift += 7 { 9797 if shift >= 64 { 9798 return ErrIntOverflow 9799 } 9800 if iNdEx >= l { 9801 return io.ErrUnexpectedEOF 9802 } 9803 b := dAtA[iNdEx] 9804 iNdEx++ 9805 msglen |= int(b&0x7F) << shift 9806 if b < 0x80 { 9807 break 9808 } 9809 } 9810 if msglen < 0 { 9811 return ErrInvalidLength 9812 } 9813 postIndex := iNdEx + msglen 9814 if postIndex < 0 { 9815 return ErrInvalidLength 9816 } 9817 if postIndex > l { 9818 return io.ErrUnexpectedEOF 9819 } 9820 if m.EffectiveCallerId == nil { 9821 m.EffectiveCallerId = &vtrpc.CallerID{} 9822 } 9823 if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 9824 return err 9825 } 9826 iNdEx = postIndex 9827 case 2: 9828 if wireType != 2 { 9829 return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType) 9830 } 9831 var msglen int 9832 for shift := uint(0); ; shift += 7 { 9833 if shift >= 64 { 9834 return ErrIntOverflow 9835 } 9836 if iNdEx >= l { 9837 return io.ErrUnexpectedEOF 9838 } 9839 b := dAtA[iNdEx] 9840 iNdEx++ 9841 msglen |= int(b&0x7F) << shift 9842 if b < 0x80 { 9843 break 9844 } 9845 } 9846 if msglen < 0 { 9847 return ErrInvalidLength 9848 } 9849 postIndex := iNdEx + msglen 9850 if postIndex < 0 { 9851 return ErrInvalidLength 9852 } 9853 if postIndex > l { 9854 return io.ErrUnexpectedEOF 9855 } 9856 if m.ImmediateCallerId == nil { 9857 m.ImmediateCallerId = &VTGateCallerID{} 9858 } 9859 if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 9860 return err 9861 } 9862 iNdEx = postIndex 9863 case 3: 9864 if wireType != 2 { 9865 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 9866 } 9867 var msglen int 9868 for shift := uint(0); ; shift += 7 { 9869 if shift >= 64 { 9870 return ErrIntOverflow 9871 } 9872 if iNdEx >= l { 9873 return io.ErrUnexpectedEOF 9874 } 9875 b := dAtA[iNdEx] 9876 iNdEx++ 9877 msglen |= int(b&0x7F) << shift 9878 if b < 0x80 { 9879 break 9880 } 9881 } 9882 if msglen < 0 { 9883 return ErrInvalidLength 9884 } 9885 postIndex := iNdEx + msglen 9886 if postIndex < 0 { 9887 return ErrInvalidLength 9888 } 9889 if postIndex > l { 9890 return io.ErrUnexpectedEOF 9891 } 9892 if m.Target == nil { 9893 m.Target = &Target{} 9894 } 9895 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 9896 return err 9897 } 9898 iNdEx = postIndex 9899 case 4: 9900 if wireType != 2 { 9901 return fmt.Errorf("proto: wrong wireType = %d for field Dtid", wireType) 9902 } 9903 var stringLen uint64 9904 for shift := uint(0); ; shift += 7 { 9905 if shift >= 64 { 9906 return ErrIntOverflow 9907 } 9908 if iNdEx >= l { 9909 return io.ErrUnexpectedEOF 9910 } 9911 b := dAtA[iNdEx] 9912 iNdEx++ 9913 stringLen |= uint64(b&0x7F) << shift 9914 if b < 0x80 { 9915 break 9916 } 9917 } 9918 intStringLen := int(stringLen) 9919 if intStringLen < 0 { 9920 return ErrInvalidLength 9921 } 9922 postIndex := iNdEx + intStringLen 9923 if postIndex < 0 { 9924 return ErrInvalidLength 9925 } 9926 if postIndex > l { 9927 return io.ErrUnexpectedEOF 9928 } 9929 m.Dtid = string(dAtA[iNdEx:postIndex]) 9930 iNdEx = postIndex 9931 default: 9932 iNdEx = preIndex 9933 skippy, err := skip(dAtA[iNdEx:]) 9934 if err != nil { 9935 return err 9936 } 9937 if (skippy < 0) || (iNdEx+skippy) < 0 { 9938 return ErrInvalidLength 9939 } 9940 if (iNdEx + skippy) > l { 9941 return io.ErrUnexpectedEOF 9942 } 9943 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 9944 iNdEx += skippy 9945 } 9946 } 9947 9948 if iNdEx > l { 9949 return io.ErrUnexpectedEOF 9950 } 9951 return nil 9952 } 9953 func (m *CommitPreparedResponse) UnmarshalVT(dAtA []byte) error { 9954 l := len(dAtA) 9955 iNdEx := 0 9956 for iNdEx < l { 9957 preIndex := iNdEx 9958 var wire uint64 9959 for shift := uint(0); ; shift += 7 { 9960 if shift >= 64 { 9961 return ErrIntOverflow 9962 } 9963 if iNdEx >= l { 9964 return io.ErrUnexpectedEOF 9965 } 9966 b := dAtA[iNdEx] 9967 iNdEx++ 9968 wire |= uint64(b&0x7F) << shift 9969 if b < 0x80 { 9970 break 9971 } 9972 } 9973 fieldNum := int32(wire >> 3) 9974 wireType := int(wire & 0x7) 9975 if wireType == 4 { 9976 return fmt.Errorf("proto: CommitPreparedResponse: wiretype end group for non-group") 9977 } 9978 if fieldNum <= 0 { 9979 return fmt.Errorf("proto: CommitPreparedResponse: illegal tag %d (wire type %d)", fieldNum, wire) 9980 } 9981 switch fieldNum { 9982 default: 9983 iNdEx = preIndex 9984 skippy, err := skip(dAtA[iNdEx:]) 9985 if err != nil { 9986 return err 9987 } 9988 if (skippy < 0) || (iNdEx+skippy) < 0 { 9989 return ErrInvalidLength 9990 } 9991 if (iNdEx + skippy) > l { 9992 return io.ErrUnexpectedEOF 9993 } 9994 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 9995 iNdEx += skippy 9996 } 9997 } 9998 9999 if iNdEx > l { 10000 return io.ErrUnexpectedEOF 10001 } 10002 return nil 10003 } 10004 func (m *RollbackPreparedRequest) UnmarshalVT(dAtA []byte) error { 10005 l := len(dAtA) 10006 iNdEx := 0 10007 for iNdEx < l { 10008 preIndex := iNdEx 10009 var wire uint64 10010 for shift := uint(0); ; shift += 7 { 10011 if shift >= 64 { 10012 return ErrIntOverflow 10013 } 10014 if iNdEx >= l { 10015 return io.ErrUnexpectedEOF 10016 } 10017 b := dAtA[iNdEx] 10018 iNdEx++ 10019 wire |= uint64(b&0x7F) << shift 10020 if b < 0x80 { 10021 break 10022 } 10023 } 10024 fieldNum := int32(wire >> 3) 10025 wireType := int(wire & 0x7) 10026 if wireType == 4 { 10027 return fmt.Errorf("proto: RollbackPreparedRequest: wiretype end group for non-group") 10028 } 10029 if fieldNum <= 0 { 10030 return fmt.Errorf("proto: RollbackPreparedRequest: illegal tag %d (wire type %d)", fieldNum, wire) 10031 } 10032 switch fieldNum { 10033 case 1: 10034 if wireType != 2 { 10035 return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType) 10036 } 10037 var msglen int 10038 for shift := uint(0); ; shift += 7 { 10039 if shift >= 64 { 10040 return ErrIntOverflow 10041 } 10042 if iNdEx >= l { 10043 return io.ErrUnexpectedEOF 10044 } 10045 b := dAtA[iNdEx] 10046 iNdEx++ 10047 msglen |= int(b&0x7F) << shift 10048 if b < 0x80 { 10049 break 10050 } 10051 } 10052 if msglen < 0 { 10053 return ErrInvalidLength 10054 } 10055 postIndex := iNdEx + msglen 10056 if postIndex < 0 { 10057 return ErrInvalidLength 10058 } 10059 if postIndex > l { 10060 return io.ErrUnexpectedEOF 10061 } 10062 if m.EffectiveCallerId == nil { 10063 m.EffectiveCallerId = &vtrpc.CallerID{} 10064 } 10065 if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 10066 return err 10067 } 10068 iNdEx = postIndex 10069 case 2: 10070 if wireType != 2 { 10071 return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType) 10072 } 10073 var msglen int 10074 for shift := uint(0); ; shift += 7 { 10075 if shift >= 64 { 10076 return ErrIntOverflow 10077 } 10078 if iNdEx >= l { 10079 return io.ErrUnexpectedEOF 10080 } 10081 b := dAtA[iNdEx] 10082 iNdEx++ 10083 msglen |= int(b&0x7F) << shift 10084 if b < 0x80 { 10085 break 10086 } 10087 } 10088 if msglen < 0 { 10089 return ErrInvalidLength 10090 } 10091 postIndex := iNdEx + msglen 10092 if postIndex < 0 { 10093 return ErrInvalidLength 10094 } 10095 if postIndex > l { 10096 return io.ErrUnexpectedEOF 10097 } 10098 if m.ImmediateCallerId == nil { 10099 m.ImmediateCallerId = &VTGateCallerID{} 10100 } 10101 if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 10102 return err 10103 } 10104 iNdEx = postIndex 10105 case 3: 10106 if wireType != 2 { 10107 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 10108 } 10109 var msglen int 10110 for shift := uint(0); ; shift += 7 { 10111 if shift >= 64 { 10112 return ErrIntOverflow 10113 } 10114 if iNdEx >= l { 10115 return io.ErrUnexpectedEOF 10116 } 10117 b := dAtA[iNdEx] 10118 iNdEx++ 10119 msglen |= int(b&0x7F) << shift 10120 if b < 0x80 { 10121 break 10122 } 10123 } 10124 if msglen < 0 { 10125 return ErrInvalidLength 10126 } 10127 postIndex := iNdEx + msglen 10128 if postIndex < 0 { 10129 return ErrInvalidLength 10130 } 10131 if postIndex > l { 10132 return io.ErrUnexpectedEOF 10133 } 10134 if m.Target == nil { 10135 m.Target = &Target{} 10136 } 10137 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 10138 return err 10139 } 10140 iNdEx = postIndex 10141 case 4: 10142 if wireType != 0 { 10143 return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType) 10144 } 10145 m.TransactionId = 0 10146 for shift := uint(0); ; shift += 7 { 10147 if shift >= 64 { 10148 return ErrIntOverflow 10149 } 10150 if iNdEx >= l { 10151 return io.ErrUnexpectedEOF 10152 } 10153 b := dAtA[iNdEx] 10154 iNdEx++ 10155 m.TransactionId |= int64(b&0x7F) << shift 10156 if b < 0x80 { 10157 break 10158 } 10159 } 10160 case 5: 10161 if wireType != 2 { 10162 return fmt.Errorf("proto: wrong wireType = %d for field Dtid", wireType) 10163 } 10164 var stringLen uint64 10165 for shift := uint(0); ; shift += 7 { 10166 if shift >= 64 { 10167 return ErrIntOverflow 10168 } 10169 if iNdEx >= l { 10170 return io.ErrUnexpectedEOF 10171 } 10172 b := dAtA[iNdEx] 10173 iNdEx++ 10174 stringLen |= uint64(b&0x7F) << shift 10175 if b < 0x80 { 10176 break 10177 } 10178 } 10179 intStringLen := int(stringLen) 10180 if intStringLen < 0 { 10181 return ErrInvalidLength 10182 } 10183 postIndex := iNdEx + intStringLen 10184 if postIndex < 0 { 10185 return ErrInvalidLength 10186 } 10187 if postIndex > l { 10188 return io.ErrUnexpectedEOF 10189 } 10190 m.Dtid = string(dAtA[iNdEx:postIndex]) 10191 iNdEx = postIndex 10192 default: 10193 iNdEx = preIndex 10194 skippy, err := skip(dAtA[iNdEx:]) 10195 if err != nil { 10196 return err 10197 } 10198 if (skippy < 0) || (iNdEx+skippy) < 0 { 10199 return ErrInvalidLength 10200 } 10201 if (iNdEx + skippy) > l { 10202 return io.ErrUnexpectedEOF 10203 } 10204 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 10205 iNdEx += skippy 10206 } 10207 } 10208 10209 if iNdEx > l { 10210 return io.ErrUnexpectedEOF 10211 } 10212 return nil 10213 } 10214 func (m *RollbackPreparedResponse) UnmarshalVT(dAtA []byte) error { 10215 l := len(dAtA) 10216 iNdEx := 0 10217 for iNdEx < l { 10218 preIndex := iNdEx 10219 var wire uint64 10220 for shift := uint(0); ; shift += 7 { 10221 if shift >= 64 { 10222 return ErrIntOverflow 10223 } 10224 if iNdEx >= l { 10225 return io.ErrUnexpectedEOF 10226 } 10227 b := dAtA[iNdEx] 10228 iNdEx++ 10229 wire |= uint64(b&0x7F) << shift 10230 if b < 0x80 { 10231 break 10232 } 10233 } 10234 fieldNum := int32(wire >> 3) 10235 wireType := int(wire & 0x7) 10236 if wireType == 4 { 10237 return fmt.Errorf("proto: RollbackPreparedResponse: wiretype end group for non-group") 10238 } 10239 if fieldNum <= 0 { 10240 return fmt.Errorf("proto: RollbackPreparedResponse: illegal tag %d (wire type %d)", fieldNum, wire) 10241 } 10242 switch fieldNum { 10243 default: 10244 iNdEx = preIndex 10245 skippy, err := skip(dAtA[iNdEx:]) 10246 if err != nil { 10247 return err 10248 } 10249 if (skippy < 0) || (iNdEx+skippy) < 0 { 10250 return ErrInvalidLength 10251 } 10252 if (iNdEx + skippy) > l { 10253 return io.ErrUnexpectedEOF 10254 } 10255 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 10256 iNdEx += skippy 10257 } 10258 } 10259 10260 if iNdEx > l { 10261 return io.ErrUnexpectedEOF 10262 } 10263 return nil 10264 } 10265 func (m *CreateTransactionRequest) UnmarshalVT(dAtA []byte) error { 10266 l := len(dAtA) 10267 iNdEx := 0 10268 for iNdEx < l { 10269 preIndex := iNdEx 10270 var wire uint64 10271 for shift := uint(0); ; shift += 7 { 10272 if shift >= 64 { 10273 return ErrIntOverflow 10274 } 10275 if iNdEx >= l { 10276 return io.ErrUnexpectedEOF 10277 } 10278 b := dAtA[iNdEx] 10279 iNdEx++ 10280 wire |= uint64(b&0x7F) << shift 10281 if b < 0x80 { 10282 break 10283 } 10284 } 10285 fieldNum := int32(wire >> 3) 10286 wireType := int(wire & 0x7) 10287 if wireType == 4 { 10288 return fmt.Errorf("proto: CreateTransactionRequest: wiretype end group for non-group") 10289 } 10290 if fieldNum <= 0 { 10291 return fmt.Errorf("proto: CreateTransactionRequest: illegal tag %d (wire type %d)", fieldNum, wire) 10292 } 10293 switch fieldNum { 10294 case 1: 10295 if wireType != 2 { 10296 return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType) 10297 } 10298 var msglen int 10299 for shift := uint(0); ; shift += 7 { 10300 if shift >= 64 { 10301 return ErrIntOverflow 10302 } 10303 if iNdEx >= l { 10304 return io.ErrUnexpectedEOF 10305 } 10306 b := dAtA[iNdEx] 10307 iNdEx++ 10308 msglen |= int(b&0x7F) << shift 10309 if b < 0x80 { 10310 break 10311 } 10312 } 10313 if msglen < 0 { 10314 return ErrInvalidLength 10315 } 10316 postIndex := iNdEx + msglen 10317 if postIndex < 0 { 10318 return ErrInvalidLength 10319 } 10320 if postIndex > l { 10321 return io.ErrUnexpectedEOF 10322 } 10323 if m.EffectiveCallerId == nil { 10324 m.EffectiveCallerId = &vtrpc.CallerID{} 10325 } 10326 if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 10327 return err 10328 } 10329 iNdEx = postIndex 10330 case 2: 10331 if wireType != 2 { 10332 return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType) 10333 } 10334 var msglen int 10335 for shift := uint(0); ; shift += 7 { 10336 if shift >= 64 { 10337 return ErrIntOverflow 10338 } 10339 if iNdEx >= l { 10340 return io.ErrUnexpectedEOF 10341 } 10342 b := dAtA[iNdEx] 10343 iNdEx++ 10344 msglen |= int(b&0x7F) << shift 10345 if b < 0x80 { 10346 break 10347 } 10348 } 10349 if msglen < 0 { 10350 return ErrInvalidLength 10351 } 10352 postIndex := iNdEx + msglen 10353 if postIndex < 0 { 10354 return ErrInvalidLength 10355 } 10356 if postIndex > l { 10357 return io.ErrUnexpectedEOF 10358 } 10359 if m.ImmediateCallerId == nil { 10360 m.ImmediateCallerId = &VTGateCallerID{} 10361 } 10362 if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 10363 return err 10364 } 10365 iNdEx = postIndex 10366 case 3: 10367 if wireType != 2 { 10368 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 10369 } 10370 var msglen int 10371 for shift := uint(0); ; shift += 7 { 10372 if shift >= 64 { 10373 return ErrIntOverflow 10374 } 10375 if iNdEx >= l { 10376 return io.ErrUnexpectedEOF 10377 } 10378 b := dAtA[iNdEx] 10379 iNdEx++ 10380 msglen |= int(b&0x7F) << shift 10381 if b < 0x80 { 10382 break 10383 } 10384 } 10385 if msglen < 0 { 10386 return ErrInvalidLength 10387 } 10388 postIndex := iNdEx + msglen 10389 if postIndex < 0 { 10390 return ErrInvalidLength 10391 } 10392 if postIndex > l { 10393 return io.ErrUnexpectedEOF 10394 } 10395 if m.Target == nil { 10396 m.Target = &Target{} 10397 } 10398 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 10399 return err 10400 } 10401 iNdEx = postIndex 10402 case 4: 10403 if wireType != 2 { 10404 return fmt.Errorf("proto: wrong wireType = %d for field Dtid", wireType) 10405 } 10406 var stringLen uint64 10407 for shift := uint(0); ; shift += 7 { 10408 if shift >= 64 { 10409 return ErrIntOverflow 10410 } 10411 if iNdEx >= l { 10412 return io.ErrUnexpectedEOF 10413 } 10414 b := dAtA[iNdEx] 10415 iNdEx++ 10416 stringLen |= uint64(b&0x7F) << shift 10417 if b < 0x80 { 10418 break 10419 } 10420 } 10421 intStringLen := int(stringLen) 10422 if intStringLen < 0 { 10423 return ErrInvalidLength 10424 } 10425 postIndex := iNdEx + intStringLen 10426 if postIndex < 0 { 10427 return ErrInvalidLength 10428 } 10429 if postIndex > l { 10430 return io.ErrUnexpectedEOF 10431 } 10432 m.Dtid = string(dAtA[iNdEx:postIndex]) 10433 iNdEx = postIndex 10434 case 5: 10435 if wireType != 2 { 10436 return fmt.Errorf("proto: wrong wireType = %d for field Participants", wireType) 10437 } 10438 var msglen int 10439 for shift := uint(0); ; shift += 7 { 10440 if shift >= 64 { 10441 return ErrIntOverflow 10442 } 10443 if iNdEx >= l { 10444 return io.ErrUnexpectedEOF 10445 } 10446 b := dAtA[iNdEx] 10447 iNdEx++ 10448 msglen |= int(b&0x7F) << shift 10449 if b < 0x80 { 10450 break 10451 } 10452 } 10453 if msglen < 0 { 10454 return ErrInvalidLength 10455 } 10456 postIndex := iNdEx + msglen 10457 if postIndex < 0 { 10458 return ErrInvalidLength 10459 } 10460 if postIndex > l { 10461 return io.ErrUnexpectedEOF 10462 } 10463 m.Participants = append(m.Participants, &Target{}) 10464 if err := m.Participants[len(m.Participants)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 10465 return err 10466 } 10467 iNdEx = postIndex 10468 default: 10469 iNdEx = preIndex 10470 skippy, err := skip(dAtA[iNdEx:]) 10471 if err != nil { 10472 return err 10473 } 10474 if (skippy < 0) || (iNdEx+skippy) < 0 { 10475 return ErrInvalidLength 10476 } 10477 if (iNdEx + skippy) > l { 10478 return io.ErrUnexpectedEOF 10479 } 10480 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 10481 iNdEx += skippy 10482 } 10483 } 10484 10485 if iNdEx > l { 10486 return io.ErrUnexpectedEOF 10487 } 10488 return nil 10489 } 10490 func (m *CreateTransactionResponse) UnmarshalVT(dAtA []byte) error { 10491 l := len(dAtA) 10492 iNdEx := 0 10493 for iNdEx < l { 10494 preIndex := iNdEx 10495 var wire uint64 10496 for shift := uint(0); ; shift += 7 { 10497 if shift >= 64 { 10498 return ErrIntOverflow 10499 } 10500 if iNdEx >= l { 10501 return io.ErrUnexpectedEOF 10502 } 10503 b := dAtA[iNdEx] 10504 iNdEx++ 10505 wire |= uint64(b&0x7F) << shift 10506 if b < 0x80 { 10507 break 10508 } 10509 } 10510 fieldNum := int32(wire >> 3) 10511 wireType := int(wire & 0x7) 10512 if wireType == 4 { 10513 return fmt.Errorf("proto: CreateTransactionResponse: wiretype end group for non-group") 10514 } 10515 if fieldNum <= 0 { 10516 return fmt.Errorf("proto: CreateTransactionResponse: illegal tag %d (wire type %d)", fieldNum, wire) 10517 } 10518 switch fieldNum { 10519 default: 10520 iNdEx = preIndex 10521 skippy, err := skip(dAtA[iNdEx:]) 10522 if err != nil { 10523 return err 10524 } 10525 if (skippy < 0) || (iNdEx+skippy) < 0 { 10526 return ErrInvalidLength 10527 } 10528 if (iNdEx + skippy) > l { 10529 return io.ErrUnexpectedEOF 10530 } 10531 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 10532 iNdEx += skippy 10533 } 10534 } 10535 10536 if iNdEx > l { 10537 return io.ErrUnexpectedEOF 10538 } 10539 return nil 10540 } 10541 func (m *StartCommitRequest) UnmarshalVT(dAtA []byte) error { 10542 l := len(dAtA) 10543 iNdEx := 0 10544 for iNdEx < l { 10545 preIndex := iNdEx 10546 var wire uint64 10547 for shift := uint(0); ; shift += 7 { 10548 if shift >= 64 { 10549 return ErrIntOverflow 10550 } 10551 if iNdEx >= l { 10552 return io.ErrUnexpectedEOF 10553 } 10554 b := dAtA[iNdEx] 10555 iNdEx++ 10556 wire |= uint64(b&0x7F) << shift 10557 if b < 0x80 { 10558 break 10559 } 10560 } 10561 fieldNum := int32(wire >> 3) 10562 wireType := int(wire & 0x7) 10563 if wireType == 4 { 10564 return fmt.Errorf("proto: StartCommitRequest: wiretype end group for non-group") 10565 } 10566 if fieldNum <= 0 { 10567 return fmt.Errorf("proto: StartCommitRequest: illegal tag %d (wire type %d)", fieldNum, wire) 10568 } 10569 switch fieldNum { 10570 case 1: 10571 if wireType != 2 { 10572 return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType) 10573 } 10574 var msglen int 10575 for shift := uint(0); ; shift += 7 { 10576 if shift >= 64 { 10577 return ErrIntOverflow 10578 } 10579 if iNdEx >= l { 10580 return io.ErrUnexpectedEOF 10581 } 10582 b := dAtA[iNdEx] 10583 iNdEx++ 10584 msglen |= int(b&0x7F) << shift 10585 if b < 0x80 { 10586 break 10587 } 10588 } 10589 if msglen < 0 { 10590 return ErrInvalidLength 10591 } 10592 postIndex := iNdEx + msglen 10593 if postIndex < 0 { 10594 return ErrInvalidLength 10595 } 10596 if postIndex > l { 10597 return io.ErrUnexpectedEOF 10598 } 10599 if m.EffectiveCallerId == nil { 10600 m.EffectiveCallerId = &vtrpc.CallerID{} 10601 } 10602 if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 10603 return err 10604 } 10605 iNdEx = postIndex 10606 case 2: 10607 if wireType != 2 { 10608 return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType) 10609 } 10610 var msglen int 10611 for shift := uint(0); ; shift += 7 { 10612 if shift >= 64 { 10613 return ErrIntOverflow 10614 } 10615 if iNdEx >= l { 10616 return io.ErrUnexpectedEOF 10617 } 10618 b := dAtA[iNdEx] 10619 iNdEx++ 10620 msglen |= int(b&0x7F) << shift 10621 if b < 0x80 { 10622 break 10623 } 10624 } 10625 if msglen < 0 { 10626 return ErrInvalidLength 10627 } 10628 postIndex := iNdEx + msglen 10629 if postIndex < 0 { 10630 return ErrInvalidLength 10631 } 10632 if postIndex > l { 10633 return io.ErrUnexpectedEOF 10634 } 10635 if m.ImmediateCallerId == nil { 10636 m.ImmediateCallerId = &VTGateCallerID{} 10637 } 10638 if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 10639 return err 10640 } 10641 iNdEx = postIndex 10642 case 3: 10643 if wireType != 2 { 10644 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 10645 } 10646 var msglen int 10647 for shift := uint(0); ; shift += 7 { 10648 if shift >= 64 { 10649 return ErrIntOverflow 10650 } 10651 if iNdEx >= l { 10652 return io.ErrUnexpectedEOF 10653 } 10654 b := dAtA[iNdEx] 10655 iNdEx++ 10656 msglen |= int(b&0x7F) << shift 10657 if b < 0x80 { 10658 break 10659 } 10660 } 10661 if msglen < 0 { 10662 return ErrInvalidLength 10663 } 10664 postIndex := iNdEx + msglen 10665 if postIndex < 0 { 10666 return ErrInvalidLength 10667 } 10668 if postIndex > l { 10669 return io.ErrUnexpectedEOF 10670 } 10671 if m.Target == nil { 10672 m.Target = &Target{} 10673 } 10674 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 10675 return err 10676 } 10677 iNdEx = postIndex 10678 case 4: 10679 if wireType != 0 { 10680 return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType) 10681 } 10682 m.TransactionId = 0 10683 for shift := uint(0); ; shift += 7 { 10684 if shift >= 64 { 10685 return ErrIntOverflow 10686 } 10687 if iNdEx >= l { 10688 return io.ErrUnexpectedEOF 10689 } 10690 b := dAtA[iNdEx] 10691 iNdEx++ 10692 m.TransactionId |= int64(b&0x7F) << shift 10693 if b < 0x80 { 10694 break 10695 } 10696 } 10697 case 5: 10698 if wireType != 2 { 10699 return fmt.Errorf("proto: wrong wireType = %d for field Dtid", wireType) 10700 } 10701 var stringLen uint64 10702 for shift := uint(0); ; shift += 7 { 10703 if shift >= 64 { 10704 return ErrIntOverflow 10705 } 10706 if iNdEx >= l { 10707 return io.ErrUnexpectedEOF 10708 } 10709 b := dAtA[iNdEx] 10710 iNdEx++ 10711 stringLen |= uint64(b&0x7F) << shift 10712 if b < 0x80 { 10713 break 10714 } 10715 } 10716 intStringLen := int(stringLen) 10717 if intStringLen < 0 { 10718 return ErrInvalidLength 10719 } 10720 postIndex := iNdEx + intStringLen 10721 if postIndex < 0 { 10722 return ErrInvalidLength 10723 } 10724 if postIndex > l { 10725 return io.ErrUnexpectedEOF 10726 } 10727 m.Dtid = string(dAtA[iNdEx:postIndex]) 10728 iNdEx = postIndex 10729 default: 10730 iNdEx = preIndex 10731 skippy, err := skip(dAtA[iNdEx:]) 10732 if err != nil { 10733 return err 10734 } 10735 if (skippy < 0) || (iNdEx+skippy) < 0 { 10736 return ErrInvalidLength 10737 } 10738 if (iNdEx + skippy) > l { 10739 return io.ErrUnexpectedEOF 10740 } 10741 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 10742 iNdEx += skippy 10743 } 10744 } 10745 10746 if iNdEx > l { 10747 return io.ErrUnexpectedEOF 10748 } 10749 return nil 10750 } 10751 func (m *StartCommitResponse) UnmarshalVT(dAtA []byte) error { 10752 l := len(dAtA) 10753 iNdEx := 0 10754 for iNdEx < l { 10755 preIndex := iNdEx 10756 var wire uint64 10757 for shift := uint(0); ; shift += 7 { 10758 if shift >= 64 { 10759 return ErrIntOverflow 10760 } 10761 if iNdEx >= l { 10762 return io.ErrUnexpectedEOF 10763 } 10764 b := dAtA[iNdEx] 10765 iNdEx++ 10766 wire |= uint64(b&0x7F) << shift 10767 if b < 0x80 { 10768 break 10769 } 10770 } 10771 fieldNum := int32(wire >> 3) 10772 wireType := int(wire & 0x7) 10773 if wireType == 4 { 10774 return fmt.Errorf("proto: StartCommitResponse: wiretype end group for non-group") 10775 } 10776 if fieldNum <= 0 { 10777 return fmt.Errorf("proto: StartCommitResponse: illegal tag %d (wire type %d)", fieldNum, wire) 10778 } 10779 switch fieldNum { 10780 default: 10781 iNdEx = preIndex 10782 skippy, err := skip(dAtA[iNdEx:]) 10783 if err != nil { 10784 return err 10785 } 10786 if (skippy < 0) || (iNdEx+skippy) < 0 { 10787 return ErrInvalidLength 10788 } 10789 if (iNdEx + skippy) > l { 10790 return io.ErrUnexpectedEOF 10791 } 10792 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 10793 iNdEx += skippy 10794 } 10795 } 10796 10797 if iNdEx > l { 10798 return io.ErrUnexpectedEOF 10799 } 10800 return nil 10801 } 10802 func (m *SetRollbackRequest) UnmarshalVT(dAtA []byte) error { 10803 l := len(dAtA) 10804 iNdEx := 0 10805 for iNdEx < l { 10806 preIndex := iNdEx 10807 var wire uint64 10808 for shift := uint(0); ; shift += 7 { 10809 if shift >= 64 { 10810 return ErrIntOverflow 10811 } 10812 if iNdEx >= l { 10813 return io.ErrUnexpectedEOF 10814 } 10815 b := dAtA[iNdEx] 10816 iNdEx++ 10817 wire |= uint64(b&0x7F) << shift 10818 if b < 0x80 { 10819 break 10820 } 10821 } 10822 fieldNum := int32(wire >> 3) 10823 wireType := int(wire & 0x7) 10824 if wireType == 4 { 10825 return fmt.Errorf("proto: SetRollbackRequest: wiretype end group for non-group") 10826 } 10827 if fieldNum <= 0 { 10828 return fmt.Errorf("proto: SetRollbackRequest: illegal tag %d (wire type %d)", fieldNum, wire) 10829 } 10830 switch fieldNum { 10831 case 1: 10832 if wireType != 2 { 10833 return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType) 10834 } 10835 var msglen int 10836 for shift := uint(0); ; shift += 7 { 10837 if shift >= 64 { 10838 return ErrIntOverflow 10839 } 10840 if iNdEx >= l { 10841 return io.ErrUnexpectedEOF 10842 } 10843 b := dAtA[iNdEx] 10844 iNdEx++ 10845 msglen |= int(b&0x7F) << shift 10846 if b < 0x80 { 10847 break 10848 } 10849 } 10850 if msglen < 0 { 10851 return ErrInvalidLength 10852 } 10853 postIndex := iNdEx + msglen 10854 if postIndex < 0 { 10855 return ErrInvalidLength 10856 } 10857 if postIndex > l { 10858 return io.ErrUnexpectedEOF 10859 } 10860 if m.EffectiveCallerId == nil { 10861 m.EffectiveCallerId = &vtrpc.CallerID{} 10862 } 10863 if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 10864 return err 10865 } 10866 iNdEx = postIndex 10867 case 2: 10868 if wireType != 2 { 10869 return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType) 10870 } 10871 var msglen int 10872 for shift := uint(0); ; shift += 7 { 10873 if shift >= 64 { 10874 return ErrIntOverflow 10875 } 10876 if iNdEx >= l { 10877 return io.ErrUnexpectedEOF 10878 } 10879 b := dAtA[iNdEx] 10880 iNdEx++ 10881 msglen |= int(b&0x7F) << shift 10882 if b < 0x80 { 10883 break 10884 } 10885 } 10886 if msglen < 0 { 10887 return ErrInvalidLength 10888 } 10889 postIndex := iNdEx + msglen 10890 if postIndex < 0 { 10891 return ErrInvalidLength 10892 } 10893 if postIndex > l { 10894 return io.ErrUnexpectedEOF 10895 } 10896 if m.ImmediateCallerId == nil { 10897 m.ImmediateCallerId = &VTGateCallerID{} 10898 } 10899 if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 10900 return err 10901 } 10902 iNdEx = postIndex 10903 case 3: 10904 if wireType != 2 { 10905 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 10906 } 10907 var msglen int 10908 for shift := uint(0); ; shift += 7 { 10909 if shift >= 64 { 10910 return ErrIntOverflow 10911 } 10912 if iNdEx >= l { 10913 return io.ErrUnexpectedEOF 10914 } 10915 b := dAtA[iNdEx] 10916 iNdEx++ 10917 msglen |= int(b&0x7F) << shift 10918 if b < 0x80 { 10919 break 10920 } 10921 } 10922 if msglen < 0 { 10923 return ErrInvalidLength 10924 } 10925 postIndex := iNdEx + msglen 10926 if postIndex < 0 { 10927 return ErrInvalidLength 10928 } 10929 if postIndex > l { 10930 return io.ErrUnexpectedEOF 10931 } 10932 if m.Target == nil { 10933 m.Target = &Target{} 10934 } 10935 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 10936 return err 10937 } 10938 iNdEx = postIndex 10939 case 4: 10940 if wireType != 0 { 10941 return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType) 10942 } 10943 m.TransactionId = 0 10944 for shift := uint(0); ; shift += 7 { 10945 if shift >= 64 { 10946 return ErrIntOverflow 10947 } 10948 if iNdEx >= l { 10949 return io.ErrUnexpectedEOF 10950 } 10951 b := dAtA[iNdEx] 10952 iNdEx++ 10953 m.TransactionId |= int64(b&0x7F) << shift 10954 if b < 0x80 { 10955 break 10956 } 10957 } 10958 case 5: 10959 if wireType != 2 { 10960 return fmt.Errorf("proto: wrong wireType = %d for field Dtid", wireType) 10961 } 10962 var stringLen uint64 10963 for shift := uint(0); ; shift += 7 { 10964 if shift >= 64 { 10965 return ErrIntOverflow 10966 } 10967 if iNdEx >= l { 10968 return io.ErrUnexpectedEOF 10969 } 10970 b := dAtA[iNdEx] 10971 iNdEx++ 10972 stringLen |= uint64(b&0x7F) << shift 10973 if b < 0x80 { 10974 break 10975 } 10976 } 10977 intStringLen := int(stringLen) 10978 if intStringLen < 0 { 10979 return ErrInvalidLength 10980 } 10981 postIndex := iNdEx + intStringLen 10982 if postIndex < 0 { 10983 return ErrInvalidLength 10984 } 10985 if postIndex > l { 10986 return io.ErrUnexpectedEOF 10987 } 10988 m.Dtid = string(dAtA[iNdEx:postIndex]) 10989 iNdEx = postIndex 10990 default: 10991 iNdEx = preIndex 10992 skippy, err := skip(dAtA[iNdEx:]) 10993 if err != nil { 10994 return err 10995 } 10996 if (skippy < 0) || (iNdEx+skippy) < 0 { 10997 return ErrInvalidLength 10998 } 10999 if (iNdEx + skippy) > l { 11000 return io.ErrUnexpectedEOF 11001 } 11002 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 11003 iNdEx += skippy 11004 } 11005 } 11006 11007 if iNdEx > l { 11008 return io.ErrUnexpectedEOF 11009 } 11010 return nil 11011 } 11012 func (m *SetRollbackResponse) UnmarshalVT(dAtA []byte) error { 11013 l := len(dAtA) 11014 iNdEx := 0 11015 for iNdEx < l { 11016 preIndex := iNdEx 11017 var wire uint64 11018 for shift := uint(0); ; shift += 7 { 11019 if shift >= 64 { 11020 return ErrIntOverflow 11021 } 11022 if iNdEx >= l { 11023 return io.ErrUnexpectedEOF 11024 } 11025 b := dAtA[iNdEx] 11026 iNdEx++ 11027 wire |= uint64(b&0x7F) << shift 11028 if b < 0x80 { 11029 break 11030 } 11031 } 11032 fieldNum := int32(wire >> 3) 11033 wireType := int(wire & 0x7) 11034 if wireType == 4 { 11035 return fmt.Errorf("proto: SetRollbackResponse: wiretype end group for non-group") 11036 } 11037 if fieldNum <= 0 { 11038 return fmt.Errorf("proto: SetRollbackResponse: illegal tag %d (wire type %d)", fieldNum, wire) 11039 } 11040 switch fieldNum { 11041 default: 11042 iNdEx = preIndex 11043 skippy, err := skip(dAtA[iNdEx:]) 11044 if err != nil { 11045 return err 11046 } 11047 if (skippy < 0) || (iNdEx+skippy) < 0 { 11048 return ErrInvalidLength 11049 } 11050 if (iNdEx + skippy) > l { 11051 return io.ErrUnexpectedEOF 11052 } 11053 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 11054 iNdEx += skippy 11055 } 11056 } 11057 11058 if iNdEx > l { 11059 return io.ErrUnexpectedEOF 11060 } 11061 return nil 11062 } 11063 func (m *ConcludeTransactionRequest) UnmarshalVT(dAtA []byte) error { 11064 l := len(dAtA) 11065 iNdEx := 0 11066 for iNdEx < l { 11067 preIndex := iNdEx 11068 var wire uint64 11069 for shift := uint(0); ; shift += 7 { 11070 if shift >= 64 { 11071 return ErrIntOverflow 11072 } 11073 if iNdEx >= l { 11074 return io.ErrUnexpectedEOF 11075 } 11076 b := dAtA[iNdEx] 11077 iNdEx++ 11078 wire |= uint64(b&0x7F) << shift 11079 if b < 0x80 { 11080 break 11081 } 11082 } 11083 fieldNum := int32(wire >> 3) 11084 wireType := int(wire & 0x7) 11085 if wireType == 4 { 11086 return fmt.Errorf("proto: ConcludeTransactionRequest: wiretype end group for non-group") 11087 } 11088 if fieldNum <= 0 { 11089 return fmt.Errorf("proto: ConcludeTransactionRequest: illegal tag %d (wire type %d)", fieldNum, wire) 11090 } 11091 switch fieldNum { 11092 case 1: 11093 if wireType != 2 { 11094 return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType) 11095 } 11096 var msglen int 11097 for shift := uint(0); ; shift += 7 { 11098 if shift >= 64 { 11099 return ErrIntOverflow 11100 } 11101 if iNdEx >= l { 11102 return io.ErrUnexpectedEOF 11103 } 11104 b := dAtA[iNdEx] 11105 iNdEx++ 11106 msglen |= int(b&0x7F) << shift 11107 if b < 0x80 { 11108 break 11109 } 11110 } 11111 if msglen < 0 { 11112 return ErrInvalidLength 11113 } 11114 postIndex := iNdEx + msglen 11115 if postIndex < 0 { 11116 return ErrInvalidLength 11117 } 11118 if postIndex > l { 11119 return io.ErrUnexpectedEOF 11120 } 11121 if m.EffectiveCallerId == nil { 11122 m.EffectiveCallerId = &vtrpc.CallerID{} 11123 } 11124 if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 11125 return err 11126 } 11127 iNdEx = postIndex 11128 case 2: 11129 if wireType != 2 { 11130 return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType) 11131 } 11132 var msglen int 11133 for shift := uint(0); ; shift += 7 { 11134 if shift >= 64 { 11135 return ErrIntOverflow 11136 } 11137 if iNdEx >= l { 11138 return io.ErrUnexpectedEOF 11139 } 11140 b := dAtA[iNdEx] 11141 iNdEx++ 11142 msglen |= int(b&0x7F) << shift 11143 if b < 0x80 { 11144 break 11145 } 11146 } 11147 if msglen < 0 { 11148 return ErrInvalidLength 11149 } 11150 postIndex := iNdEx + msglen 11151 if postIndex < 0 { 11152 return ErrInvalidLength 11153 } 11154 if postIndex > l { 11155 return io.ErrUnexpectedEOF 11156 } 11157 if m.ImmediateCallerId == nil { 11158 m.ImmediateCallerId = &VTGateCallerID{} 11159 } 11160 if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 11161 return err 11162 } 11163 iNdEx = postIndex 11164 case 3: 11165 if wireType != 2 { 11166 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 11167 } 11168 var msglen int 11169 for shift := uint(0); ; shift += 7 { 11170 if shift >= 64 { 11171 return ErrIntOverflow 11172 } 11173 if iNdEx >= l { 11174 return io.ErrUnexpectedEOF 11175 } 11176 b := dAtA[iNdEx] 11177 iNdEx++ 11178 msglen |= int(b&0x7F) << shift 11179 if b < 0x80 { 11180 break 11181 } 11182 } 11183 if msglen < 0 { 11184 return ErrInvalidLength 11185 } 11186 postIndex := iNdEx + msglen 11187 if postIndex < 0 { 11188 return ErrInvalidLength 11189 } 11190 if postIndex > l { 11191 return io.ErrUnexpectedEOF 11192 } 11193 if m.Target == nil { 11194 m.Target = &Target{} 11195 } 11196 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 11197 return err 11198 } 11199 iNdEx = postIndex 11200 case 4: 11201 if wireType != 2 { 11202 return fmt.Errorf("proto: wrong wireType = %d for field Dtid", wireType) 11203 } 11204 var stringLen uint64 11205 for shift := uint(0); ; shift += 7 { 11206 if shift >= 64 { 11207 return ErrIntOverflow 11208 } 11209 if iNdEx >= l { 11210 return io.ErrUnexpectedEOF 11211 } 11212 b := dAtA[iNdEx] 11213 iNdEx++ 11214 stringLen |= uint64(b&0x7F) << shift 11215 if b < 0x80 { 11216 break 11217 } 11218 } 11219 intStringLen := int(stringLen) 11220 if intStringLen < 0 { 11221 return ErrInvalidLength 11222 } 11223 postIndex := iNdEx + intStringLen 11224 if postIndex < 0 { 11225 return ErrInvalidLength 11226 } 11227 if postIndex > l { 11228 return io.ErrUnexpectedEOF 11229 } 11230 m.Dtid = string(dAtA[iNdEx:postIndex]) 11231 iNdEx = postIndex 11232 default: 11233 iNdEx = preIndex 11234 skippy, err := skip(dAtA[iNdEx:]) 11235 if err != nil { 11236 return err 11237 } 11238 if (skippy < 0) || (iNdEx+skippy) < 0 { 11239 return ErrInvalidLength 11240 } 11241 if (iNdEx + skippy) > l { 11242 return io.ErrUnexpectedEOF 11243 } 11244 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 11245 iNdEx += skippy 11246 } 11247 } 11248 11249 if iNdEx > l { 11250 return io.ErrUnexpectedEOF 11251 } 11252 return nil 11253 } 11254 func (m *ConcludeTransactionResponse) UnmarshalVT(dAtA []byte) error { 11255 l := len(dAtA) 11256 iNdEx := 0 11257 for iNdEx < l { 11258 preIndex := iNdEx 11259 var wire uint64 11260 for shift := uint(0); ; shift += 7 { 11261 if shift >= 64 { 11262 return ErrIntOverflow 11263 } 11264 if iNdEx >= l { 11265 return io.ErrUnexpectedEOF 11266 } 11267 b := dAtA[iNdEx] 11268 iNdEx++ 11269 wire |= uint64(b&0x7F) << shift 11270 if b < 0x80 { 11271 break 11272 } 11273 } 11274 fieldNum := int32(wire >> 3) 11275 wireType := int(wire & 0x7) 11276 if wireType == 4 { 11277 return fmt.Errorf("proto: ConcludeTransactionResponse: wiretype end group for non-group") 11278 } 11279 if fieldNum <= 0 { 11280 return fmt.Errorf("proto: ConcludeTransactionResponse: illegal tag %d (wire type %d)", fieldNum, wire) 11281 } 11282 switch fieldNum { 11283 default: 11284 iNdEx = preIndex 11285 skippy, err := skip(dAtA[iNdEx:]) 11286 if err != nil { 11287 return err 11288 } 11289 if (skippy < 0) || (iNdEx+skippy) < 0 { 11290 return ErrInvalidLength 11291 } 11292 if (iNdEx + skippy) > l { 11293 return io.ErrUnexpectedEOF 11294 } 11295 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 11296 iNdEx += skippy 11297 } 11298 } 11299 11300 if iNdEx > l { 11301 return io.ErrUnexpectedEOF 11302 } 11303 return nil 11304 } 11305 func (m *ReadTransactionRequest) UnmarshalVT(dAtA []byte) error { 11306 l := len(dAtA) 11307 iNdEx := 0 11308 for iNdEx < l { 11309 preIndex := iNdEx 11310 var wire uint64 11311 for shift := uint(0); ; shift += 7 { 11312 if shift >= 64 { 11313 return ErrIntOverflow 11314 } 11315 if iNdEx >= l { 11316 return io.ErrUnexpectedEOF 11317 } 11318 b := dAtA[iNdEx] 11319 iNdEx++ 11320 wire |= uint64(b&0x7F) << shift 11321 if b < 0x80 { 11322 break 11323 } 11324 } 11325 fieldNum := int32(wire >> 3) 11326 wireType := int(wire & 0x7) 11327 if wireType == 4 { 11328 return fmt.Errorf("proto: ReadTransactionRequest: wiretype end group for non-group") 11329 } 11330 if fieldNum <= 0 { 11331 return fmt.Errorf("proto: ReadTransactionRequest: illegal tag %d (wire type %d)", fieldNum, wire) 11332 } 11333 switch fieldNum { 11334 case 1: 11335 if wireType != 2 { 11336 return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType) 11337 } 11338 var msglen int 11339 for shift := uint(0); ; shift += 7 { 11340 if shift >= 64 { 11341 return ErrIntOverflow 11342 } 11343 if iNdEx >= l { 11344 return io.ErrUnexpectedEOF 11345 } 11346 b := dAtA[iNdEx] 11347 iNdEx++ 11348 msglen |= int(b&0x7F) << shift 11349 if b < 0x80 { 11350 break 11351 } 11352 } 11353 if msglen < 0 { 11354 return ErrInvalidLength 11355 } 11356 postIndex := iNdEx + msglen 11357 if postIndex < 0 { 11358 return ErrInvalidLength 11359 } 11360 if postIndex > l { 11361 return io.ErrUnexpectedEOF 11362 } 11363 if m.EffectiveCallerId == nil { 11364 m.EffectiveCallerId = &vtrpc.CallerID{} 11365 } 11366 if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 11367 return err 11368 } 11369 iNdEx = postIndex 11370 case 2: 11371 if wireType != 2 { 11372 return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType) 11373 } 11374 var msglen int 11375 for shift := uint(0); ; shift += 7 { 11376 if shift >= 64 { 11377 return ErrIntOverflow 11378 } 11379 if iNdEx >= l { 11380 return io.ErrUnexpectedEOF 11381 } 11382 b := dAtA[iNdEx] 11383 iNdEx++ 11384 msglen |= int(b&0x7F) << shift 11385 if b < 0x80 { 11386 break 11387 } 11388 } 11389 if msglen < 0 { 11390 return ErrInvalidLength 11391 } 11392 postIndex := iNdEx + msglen 11393 if postIndex < 0 { 11394 return ErrInvalidLength 11395 } 11396 if postIndex > l { 11397 return io.ErrUnexpectedEOF 11398 } 11399 if m.ImmediateCallerId == nil { 11400 m.ImmediateCallerId = &VTGateCallerID{} 11401 } 11402 if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 11403 return err 11404 } 11405 iNdEx = postIndex 11406 case 3: 11407 if wireType != 2 { 11408 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 11409 } 11410 var msglen int 11411 for shift := uint(0); ; shift += 7 { 11412 if shift >= 64 { 11413 return ErrIntOverflow 11414 } 11415 if iNdEx >= l { 11416 return io.ErrUnexpectedEOF 11417 } 11418 b := dAtA[iNdEx] 11419 iNdEx++ 11420 msglen |= int(b&0x7F) << shift 11421 if b < 0x80 { 11422 break 11423 } 11424 } 11425 if msglen < 0 { 11426 return ErrInvalidLength 11427 } 11428 postIndex := iNdEx + msglen 11429 if postIndex < 0 { 11430 return ErrInvalidLength 11431 } 11432 if postIndex > l { 11433 return io.ErrUnexpectedEOF 11434 } 11435 if m.Target == nil { 11436 m.Target = &Target{} 11437 } 11438 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 11439 return err 11440 } 11441 iNdEx = postIndex 11442 case 4: 11443 if wireType != 2 { 11444 return fmt.Errorf("proto: wrong wireType = %d for field Dtid", wireType) 11445 } 11446 var stringLen uint64 11447 for shift := uint(0); ; shift += 7 { 11448 if shift >= 64 { 11449 return ErrIntOverflow 11450 } 11451 if iNdEx >= l { 11452 return io.ErrUnexpectedEOF 11453 } 11454 b := dAtA[iNdEx] 11455 iNdEx++ 11456 stringLen |= uint64(b&0x7F) << shift 11457 if b < 0x80 { 11458 break 11459 } 11460 } 11461 intStringLen := int(stringLen) 11462 if intStringLen < 0 { 11463 return ErrInvalidLength 11464 } 11465 postIndex := iNdEx + intStringLen 11466 if postIndex < 0 { 11467 return ErrInvalidLength 11468 } 11469 if postIndex > l { 11470 return io.ErrUnexpectedEOF 11471 } 11472 m.Dtid = string(dAtA[iNdEx:postIndex]) 11473 iNdEx = postIndex 11474 default: 11475 iNdEx = preIndex 11476 skippy, err := skip(dAtA[iNdEx:]) 11477 if err != nil { 11478 return err 11479 } 11480 if (skippy < 0) || (iNdEx+skippy) < 0 { 11481 return ErrInvalidLength 11482 } 11483 if (iNdEx + skippy) > l { 11484 return io.ErrUnexpectedEOF 11485 } 11486 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 11487 iNdEx += skippy 11488 } 11489 } 11490 11491 if iNdEx > l { 11492 return io.ErrUnexpectedEOF 11493 } 11494 return nil 11495 } 11496 func (m *ReadTransactionResponse) UnmarshalVT(dAtA []byte) error { 11497 l := len(dAtA) 11498 iNdEx := 0 11499 for iNdEx < l { 11500 preIndex := iNdEx 11501 var wire uint64 11502 for shift := uint(0); ; shift += 7 { 11503 if shift >= 64 { 11504 return ErrIntOverflow 11505 } 11506 if iNdEx >= l { 11507 return io.ErrUnexpectedEOF 11508 } 11509 b := dAtA[iNdEx] 11510 iNdEx++ 11511 wire |= uint64(b&0x7F) << shift 11512 if b < 0x80 { 11513 break 11514 } 11515 } 11516 fieldNum := int32(wire >> 3) 11517 wireType := int(wire & 0x7) 11518 if wireType == 4 { 11519 return fmt.Errorf("proto: ReadTransactionResponse: wiretype end group for non-group") 11520 } 11521 if fieldNum <= 0 { 11522 return fmt.Errorf("proto: ReadTransactionResponse: illegal tag %d (wire type %d)", fieldNum, wire) 11523 } 11524 switch fieldNum { 11525 case 1: 11526 if wireType != 2 { 11527 return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) 11528 } 11529 var msglen int 11530 for shift := uint(0); ; shift += 7 { 11531 if shift >= 64 { 11532 return ErrIntOverflow 11533 } 11534 if iNdEx >= l { 11535 return io.ErrUnexpectedEOF 11536 } 11537 b := dAtA[iNdEx] 11538 iNdEx++ 11539 msglen |= int(b&0x7F) << shift 11540 if b < 0x80 { 11541 break 11542 } 11543 } 11544 if msglen < 0 { 11545 return ErrInvalidLength 11546 } 11547 postIndex := iNdEx + msglen 11548 if postIndex < 0 { 11549 return ErrInvalidLength 11550 } 11551 if postIndex > l { 11552 return io.ErrUnexpectedEOF 11553 } 11554 if m.Metadata == nil { 11555 m.Metadata = &TransactionMetadata{} 11556 } 11557 if err := m.Metadata.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 11558 return err 11559 } 11560 iNdEx = postIndex 11561 default: 11562 iNdEx = preIndex 11563 skippy, err := skip(dAtA[iNdEx:]) 11564 if err != nil { 11565 return err 11566 } 11567 if (skippy < 0) || (iNdEx+skippy) < 0 { 11568 return ErrInvalidLength 11569 } 11570 if (iNdEx + skippy) > l { 11571 return io.ErrUnexpectedEOF 11572 } 11573 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 11574 iNdEx += skippy 11575 } 11576 } 11577 11578 if iNdEx > l { 11579 return io.ErrUnexpectedEOF 11580 } 11581 return nil 11582 } 11583 func (m *BeginExecuteRequest) UnmarshalVT(dAtA []byte) error { 11584 l := len(dAtA) 11585 iNdEx := 0 11586 for iNdEx < l { 11587 preIndex := iNdEx 11588 var wire uint64 11589 for shift := uint(0); ; shift += 7 { 11590 if shift >= 64 { 11591 return ErrIntOverflow 11592 } 11593 if iNdEx >= l { 11594 return io.ErrUnexpectedEOF 11595 } 11596 b := dAtA[iNdEx] 11597 iNdEx++ 11598 wire |= uint64(b&0x7F) << shift 11599 if b < 0x80 { 11600 break 11601 } 11602 } 11603 fieldNum := int32(wire >> 3) 11604 wireType := int(wire & 0x7) 11605 if wireType == 4 { 11606 return fmt.Errorf("proto: BeginExecuteRequest: wiretype end group for non-group") 11607 } 11608 if fieldNum <= 0 { 11609 return fmt.Errorf("proto: BeginExecuteRequest: illegal tag %d (wire type %d)", fieldNum, wire) 11610 } 11611 switch fieldNum { 11612 case 1: 11613 if wireType != 2 { 11614 return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType) 11615 } 11616 var msglen int 11617 for shift := uint(0); ; shift += 7 { 11618 if shift >= 64 { 11619 return ErrIntOverflow 11620 } 11621 if iNdEx >= l { 11622 return io.ErrUnexpectedEOF 11623 } 11624 b := dAtA[iNdEx] 11625 iNdEx++ 11626 msglen |= int(b&0x7F) << shift 11627 if b < 0x80 { 11628 break 11629 } 11630 } 11631 if msglen < 0 { 11632 return ErrInvalidLength 11633 } 11634 postIndex := iNdEx + msglen 11635 if postIndex < 0 { 11636 return ErrInvalidLength 11637 } 11638 if postIndex > l { 11639 return io.ErrUnexpectedEOF 11640 } 11641 if m.EffectiveCallerId == nil { 11642 m.EffectiveCallerId = &vtrpc.CallerID{} 11643 } 11644 if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 11645 return err 11646 } 11647 iNdEx = postIndex 11648 case 2: 11649 if wireType != 2 { 11650 return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType) 11651 } 11652 var msglen int 11653 for shift := uint(0); ; shift += 7 { 11654 if shift >= 64 { 11655 return ErrIntOverflow 11656 } 11657 if iNdEx >= l { 11658 return io.ErrUnexpectedEOF 11659 } 11660 b := dAtA[iNdEx] 11661 iNdEx++ 11662 msglen |= int(b&0x7F) << shift 11663 if b < 0x80 { 11664 break 11665 } 11666 } 11667 if msglen < 0 { 11668 return ErrInvalidLength 11669 } 11670 postIndex := iNdEx + msglen 11671 if postIndex < 0 { 11672 return ErrInvalidLength 11673 } 11674 if postIndex > l { 11675 return io.ErrUnexpectedEOF 11676 } 11677 if m.ImmediateCallerId == nil { 11678 m.ImmediateCallerId = &VTGateCallerID{} 11679 } 11680 if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 11681 return err 11682 } 11683 iNdEx = postIndex 11684 case 3: 11685 if wireType != 2 { 11686 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 11687 } 11688 var msglen int 11689 for shift := uint(0); ; shift += 7 { 11690 if shift >= 64 { 11691 return ErrIntOverflow 11692 } 11693 if iNdEx >= l { 11694 return io.ErrUnexpectedEOF 11695 } 11696 b := dAtA[iNdEx] 11697 iNdEx++ 11698 msglen |= int(b&0x7F) << shift 11699 if b < 0x80 { 11700 break 11701 } 11702 } 11703 if msglen < 0 { 11704 return ErrInvalidLength 11705 } 11706 postIndex := iNdEx + msglen 11707 if postIndex < 0 { 11708 return ErrInvalidLength 11709 } 11710 if postIndex > l { 11711 return io.ErrUnexpectedEOF 11712 } 11713 if m.Target == nil { 11714 m.Target = &Target{} 11715 } 11716 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 11717 return err 11718 } 11719 iNdEx = postIndex 11720 case 4: 11721 if wireType != 2 { 11722 return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) 11723 } 11724 var msglen int 11725 for shift := uint(0); ; shift += 7 { 11726 if shift >= 64 { 11727 return ErrIntOverflow 11728 } 11729 if iNdEx >= l { 11730 return io.ErrUnexpectedEOF 11731 } 11732 b := dAtA[iNdEx] 11733 iNdEx++ 11734 msglen |= int(b&0x7F) << shift 11735 if b < 0x80 { 11736 break 11737 } 11738 } 11739 if msglen < 0 { 11740 return ErrInvalidLength 11741 } 11742 postIndex := iNdEx + msglen 11743 if postIndex < 0 { 11744 return ErrInvalidLength 11745 } 11746 if postIndex > l { 11747 return io.ErrUnexpectedEOF 11748 } 11749 if m.Query == nil { 11750 m.Query = &BoundQuery{} 11751 } 11752 if err := m.Query.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 11753 return err 11754 } 11755 iNdEx = postIndex 11756 case 5: 11757 if wireType != 2 { 11758 return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType) 11759 } 11760 var msglen int 11761 for shift := uint(0); ; shift += 7 { 11762 if shift >= 64 { 11763 return ErrIntOverflow 11764 } 11765 if iNdEx >= l { 11766 return io.ErrUnexpectedEOF 11767 } 11768 b := dAtA[iNdEx] 11769 iNdEx++ 11770 msglen |= int(b&0x7F) << shift 11771 if b < 0x80 { 11772 break 11773 } 11774 } 11775 if msglen < 0 { 11776 return ErrInvalidLength 11777 } 11778 postIndex := iNdEx + msglen 11779 if postIndex < 0 { 11780 return ErrInvalidLength 11781 } 11782 if postIndex > l { 11783 return io.ErrUnexpectedEOF 11784 } 11785 if m.Options == nil { 11786 m.Options = &ExecuteOptions{} 11787 } 11788 if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 11789 return err 11790 } 11791 iNdEx = postIndex 11792 case 6: 11793 if wireType != 0 { 11794 return fmt.Errorf("proto: wrong wireType = %d for field ReservedId", wireType) 11795 } 11796 m.ReservedId = 0 11797 for shift := uint(0); ; shift += 7 { 11798 if shift >= 64 { 11799 return ErrIntOverflow 11800 } 11801 if iNdEx >= l { 11802 return io.ErrUnexpectedEOF 11803 } 11804 b := dAtA[iNdEx] 11805 iNdEx++ 11806 m.ReservedId |= int64(b&0x7F) << shift 11807 if b < 0x80 { 11808 break 11809 } 11810 } 11811 case 7: 11812 if wireType != 2 { 11813 return fmt.Errorf("proto: wrong wireType = %d for field PreQueries", wireType) 11814 } 11815 var stringLen uint64 11816 for shift := uint(0); ; shift += 7 { 11817 if shift >= 64 { 11818 return ErrIntOverflow 11819 } 11820 if iNdEx >= l { 11821 return io.ErrUnexpectedEOF 11822 } 11823 b := dAtA[iNdEx] 11824 iNdEx++ 11825 stringLen |= uint64(b&0x7F) << shift 11826 if b < 0x80 { 11827 break 11828 } 11829 } 11830 intStringLen := int(stringLen) 11831 if intStringLen < 0 { 11832 return ErrInvalidLength 11833 } 11834 postIndex := iNdEx + intStringLen 11835 if postIndex < 0 { 11836 return ErrInvalidLength 11837 } 11838 if postIndex > l { 11839 return io.ErrUnexpectedEOF 11840 } 11841 m.PreQueries = append(m.PreQueries, string(dAtA[iNdEx:postIndex])) 11842 iNdEx = postIndex 11843 default: 11844 iNdEx = preIndex 11845 skippy, err := skip(dAtA[iNdEx:]) 11846 if err != nil { 11847 return err 11848 } 11849 if (skippy < 0) || (iNdEx+skippy) < 0 { 11850 return ErrInvalidLength 11851 } 11852 if (iNdEx + skippy) > l { 11853 return io.ErrUnexpectedEOF 11854 } 11855 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 11856 iNdEx += skippy 11857 } 11858 } 11859 11860 if iNdEx > l { 11861 return io.ErrUnexpectedEOF 11862 } 11863 return nil 11864 } 11865 func (m *BeginExecuteResponse) UnmarshalVT(dAtA []byte) error { 11866 l := len(dAtA) 11867 iNdEx := 0 11868 for iNdEx < l { 11869 preIndex := iNdEx 11870 var wire uint64 11871 for shift := uint(0); ; shift += 7 { 11872 if shift >= 64 { 11873 return ErrIntOverflow 11874 } 11875 if iNdEx >= l { 11876 return io.ErrUnexpectedEOF 11877 } 11878 b := dAtA[iNdEx] 11879 iNdEx++ 11880 wire |= uint64(b&0x7F) << shift 11881 if b < 0x80 { 11882 break 11883 } 11884 } 11885 fieldNum := int32(wire >> 3) 11886 wireType := int(wire & 0x7) 11887 if wireType == 4 { 11888 return fmt.Errorf("proto: BeginExecuteResponse: wiretype end group for non-group") 11889 } 11890 if fieldNum <= 0 { 11891 return fmt.Errorf("proto: BeginExecuteResponse: illegal tag %d (wire type %d)", fieldNum, wire) 11892 } 11893 switch fieldNum { 11894 case 1: 11895 if wireType != 2 { 11896 return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) 11897 } 11898 var msglen int 11899 for shift := uint(0); ; shift += 7 { 11900 if shift >= 64 { 11901 return ErrIntOverflow 11902 } 11903 if iNdEx >= l { 11904 return io.ErrUnexpectedEOF 11905 } 11906 b := dAtA[iNdEx] 11907 iNdEx++ 11908 msglen |= int(b&0x7F) << shift 11909 if b < 0x80 { 11910 break 11911 } 11912 } 11913 if msglen < 0 { 11914 return ErrInvalidLength 11915 } 11916 postIndex := iNdEx + msglen 11917 if postIndex < 0 { 11918 return ErrInvalidLength 11919 } 11920 if postIndex > l { 11921 return io.ErrUnexpectedEOF 11922 } 11923 if m.Error == nil { 11924 m.Error = &vtrpc.RPCError{} 11925 } 11926 if err := m.Error.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 11927 return err 11928 } 11929 iNdEx = postIndex 11930 case 2: 11931 if wireType != 2 { 11932 return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) 11933 } 11934 var msglen int 11935 for shift := uint(0); ; shift += 7 { 11936 if shift >= 64 { 11937 return ErrIntOverflow 11938 } 11939 if iNdEx >= l { 11940 return io.ErrUnexpectedEOF 11941 } 11942 b := dAtA[iNdEx] 11943 iNdEx++ 11944 msglen |= int(b&0x7F) << shift 11945 if b < 0x80 { 11946 break 11947 } 11948 } 11949 if msglen < 0 { 11950 return ErrInvalidLength 11951 } 11952 postIndex := iNdEx + msglen 11953 if postIndex < 0 { 11954 return ErrInvalidLength 11955 } 11956 if postIndex > l { 11957 return io.ErrUnexpectedEOF 11958 } 11959 if m.Result == nil { 11960 m.Result = &QueryResult{} 11961 } 11962 if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 11963 return err 11964 } 11965 iNdEx = postIndex 11966 case 3: 11967 if wireType != 0 { 11968 return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType) 11969 } 11970 m.TransactionId = 0 11971 for shift := uint(0); ; shift += 7 { 11972 if shift >= 64 { 11973 return ErrIntOverflow 11974 } 11975 if iNdEx >= l { 11976 return io.ErrUnexpectedEOF 11977 } 11978 b := dAtA[iNdEx] 11979 iNdEx++ 11980 m.TransactionId |= int64(b&0x7F) << shift 11981 if b < 0x80 { 11982 break 11983 } 11984 } 11985 case 4: 11986 if wireType != 2 { 11987 return fmt.Errorf("proto: wrong wireType = %d for field TabletAlias", wireType) 11988 } 11989 var msglen int 11990 for shift := uint(0); ; shift += 7 { 11991 if shift >= 64 { 11992 return ErrIntOverflow 11993 } 11994 if iNdEx >= l { 11995 return io.ErrUnexpectedEOF 11996 } 11997 b := dAtA[iNdEx] 11998 iNdEx++ 11999 msglen |= int(b&0x7F) << shift 12000 if b < 0x80 { 12001 break 12002 } 12003 } 12004 if msglen < 0 { 12005 return ErrInvalidLength 12006 } 12007 postIndex := iNdEx + msglen 12008 if postIndex < 0 { 12009 return ErrInvalidLength 12010 } 12011 if postIndex > l { 12012 return io.ErrUnexpectedEOF 12013 } 12014 if m.TabletAlias == nil { 12015 m.TabletAlias = &topodata.TabletAlias{} 12016 } 12017 if err := m.TabletAlias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 12018 return err 12019 } 12020 iNdEx = postIndex 12021 default: 12022 iNdEx = preIndex 12023 skippy, err := skip(dAtA[iNdEx:]) 12024 if err != nil { 12025 return err 12026 } 12027 if (skippy < 0) || (iNdEx+skippy) < 0 { 12028 return ErrInvalidLength 12029 } 12030 if (iNdEx + skippy) > l { 12031 return io.ErrUnexpectedEOF 12032 } 12033 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 12034 iNdEx += skippy 12035 } 12036 } 12037 12038 if iNdEx > l { 12039 return io.ErrUnexpectedEOF 12040 } 12041 return nil 12042 } 12043 func (m *BeginStreamExecuteRequest) UnmarshalVT(dAtA []byte) error { 12044 l := len(dAtA) 12045 iNdEx := 0 12046 for iNdEx < l { 12047 preIndex := iNdEx 12048 var wire uint64 12049 for shift := uint(0); ; shift += 7 { 12050 if shift >= 64 { 12051 return ErrIntOverflow 12052 } 12053 if iNdEx >= l { 12054 return io.ErrUnexpectedEOF 12055 } 12056 b := dAtA[iNdEx] 12057 iNdEx++ 12058 wire |= uint64(b&0x7F) << shift 12059 if b < 0x80 { 12060 break 12061 } 12062 } 12063 fieldNum := int32(wire >> 3) 12064 wireType := int(wire & 0x7) 12065 if wireType == 4 { 12066 return fmt.Errorf("proto: BeginStreamExecuteRequest: wiretype end group for non-group") 12067 } 12068 if fieldNum <= 0 { 12069 return fmt.Errorf("proto: BeginStreamExecuteRequest: illegal tag %d (wire type %d)", fieldNum, wire) 12070 } 12071 switch fieldNum { 12072 case 1: 12073 if wireType != 2 { 12074 return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType) 12075 } 12076 var msglen int 12077 for shift := uint(0); ; shift += 7 { 12078 if shift >= 64 { 12079 return ErrIntOverflow 12080 } 12081 if iNdEx >= l { 12082 return io.ErrUnexpectedEOF 12083 } 12084 b := dAtA[iNdEx] 12085 iNdEx++ 12086 msglen |= int(b&0x7F) << shift 12087 if b < 0x80 { 12088 break 12089 } 12090 } 12091 if msglen < 0 { 12092 return ErrInvalidLength 12093 } 12094 postIndex := iNdEx + msglen 12095 if postIndex < 0 { 12096 return ErrInvalidLength 12097 } 12098 if postIndex > l { 12099 return io.ErrUnexpectedEOF 12100 } 12101 if m.EffectiveCallerId == nil { 12102 m.EffectiveCallerId = &vtrpc.CallerID{} 12103 } 12104 if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 12105 return err 12106 } 12107 iNdEx = postIndex 12108 case 2: 12109 if wireType != 2 { 12110 return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType) 12111 } 12112 var msglen int 12113 for shift := uint(0); ; shift += 7 { 12114 if shift >= 64 { 12115 return ErrIntOverflow 12116 } 12117 if iNdEx >= l { 12118 return io.ErrUnexpectedEOF 12119 } 12120 b := dAtA[iNdEx] 12121 iNdEx++ 12122 msglen |= int(b&0x7F) << shift 12123 if b < 0x80 { 12124 break 12125 } 12126 } 12127 if msglen < 0 { 12128 return ErrInvalidLength 12129 } 12130 postIndex := iNdEx + msglen 12131 if postIndex < 0 { 12132 return ErrInvalidLength 12133 } 12134 if postIndex > l { 12135 return io.ErrUnexpectedEOF 12136 } 12137 if m.ImmediateCallerId == nil { 12138 m.ImmediateCallerId = &VTGateCallerID{} 12139 } 12140 if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 12141 return err 12142 } 12143 iNdEx = postIndex 12144 case 3: 12145 if wireType != 2 { 12146 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 12147 } 12148 var msglen int 12149 for shift := uint(0); ; shift += 7 { 12150 if shift >= 64 { 12151 return ErrIntOverflow 12152 } 12153 if iNdEx >= l { 12154 return io.ErrUnexpectedEOF 12155 } 12156 b := dAtA[iNdEx] 12157 iNdEx++ 12158 msglen |= int(b&0x7F) << shift 12159 if b < 0x80 { 12160 break 12161 } 12162 } 12163 if msglen < 0 { 12164 return ErrInvalidLength 12165 } 12166 postIndex := iNdEx + msglen 12167 if postIndex < 0 { 12168 return ErrInvalidLength 12169 } 12170 if postIndex > l { 12171 return io.ErrUnexpectedEOF 12172 } 12173 if m.Target == nil { 12174 m.Target = &Target{} 12175 } 12176 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 12177 return err 12178 } 12179 iNdEx = postIndex 12180 case 4: 12181 if wireType != 2 { 12182 return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) 12183 } 12184 var msglen int 12185 for shift := uint(0); ; shift += 7 { 12186 if shift >= 64 { 12187 return ErrIntOverflow 12188 } 12189 if iNdEx >= l { 12190 return io.ErrUnexpectedEOF 12191 } 12192 b := dAtA[iNdEx] 12193 iNdEx++ 12194 msglen |= int(b&0x7F) << shift 12195 if b < 0x80 { 12196 break 12197 } 12198 } 12199 if msglen < 0 { 12200 return ErrInvalidLength 12201 } 12202 postIndex := iNdEx + msglen 12203 if postIndex < 0 { 12204 return ErrInvalidLength 12205 } 12206 if postIndex > l { 12207 return io.ErrUnexpectedEOF 12208 } 12209 if m.Query == nil { 12210 m.Query = &BoundQuery{} 12211 } 12212 if err := m.Query.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 12213 return err 12214 } 12215 iNdEx = postIndex 12216 case 5: 12217 if wireType != 2 { 12218 return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType) 12219 } 12220 var msglen int 12221 for shift := uint(0); ; shift += 7 { 12222 if shift >= 64 { 12223 return ErrIntOverflow 12224 } 12225 if iNdEx >= l { 12226 return io.ErrUnexpectedEOF 12227 } 12228 b := dAtA[iNdEx] 12229 iNdEx++ 12230 msglen |= int(b&0x7F) << shift 12231 if b < 0x80 { 12232 break 12233 } 12234 } 12235 if msglen < 0 { 12236 return ErrInvalidLength 12237 } 12238 postIndex := iNdEx + msglen 12239 if postIndex < 0 { 12240 return ErrInvalidLength 12241 } 12242 if postIndex > l { 12243 return io.ErrUnexpectedEOF 12244 } 12245 if m.Options == nil { 12246 m.Options = &ExecuteOptions{} 12247 } 12248 if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 12249 return err 12250 } 12251 iNdEx = postIndex 12252 case 6: 12253 if wireType != 2 { 12254 return fmt.Errorf("proto: wrong wireType = %d for field PreQueries", wireType) 12255 } 12256 var stringLen uint64 12257 for shift := uint(0); ; shift += 7 { 12258 if shift >= 64 { 12259 return ErrIntOverflow 12260 } 12261 if iNdEx >= l { 12262 return io.ErrUnexpectedEOF 12263 } 12264 b := dAtA[iNdEx] 12265 iNdEx++ 12266 stringLen |= uint64(b&0x7F) << shift 12267 if b < 0x80 { 12268 break 12269 } 12270 } 12271 intStringLen := int(stringLen) 12272 if intStringLen < 0 { 12273 return ErrInvalidLength 12274 } 12275 postIndex := iNdEx + intStringLen 12276 if postIndex < 0 { 12277 return ErrInvalidLength 12278 } 12279 if postIndex > l { 12280 return io.ErrUnexpectedEOF 12281 } 12282 m.PreQueries = append(m.PreQueries, string(dAtA[iNdEx:postIndex])) 12283 iNdEx = postIndex 12284 case 7: 12285 if wireType != 0 { 12286 return fmt.Errorf("proto: wrong wireType = %d for field ReservedId", wireType) 12287 } 12288 m.ReservedId = 0 12289 for shift := uint(0); ; shift += 7 { 12290 if shift >= 64 { 12291 return ErrIntOverflow 12292 } 12293 if iNdEx >= l { 12294 return io.ErrUnexpectedEOF 12295 } 12296 b := dAtA[iNdEx] 12297 iNdEx++ 12298 m.ReservedId |= int64(b&0x7F) << shift 12299 if b < 0x80 { 12300 break 12301 } 12302 } 12303 default: 12304 iNdEx = preIndex 12305 skippy, err := skip(dAtA[iNdEx:]) 12306 if err != nil { 12307 return err 12308 } 12309 if (skippy < 0) || (iNdEx+skippy) < 0 { 12310 return ErrInvalidLength 12311 } 12312 if (iNdEx + skippy) > l { 12313 return io.ErrUnexpectedEOF 12314 } 12315 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 12316 iNdEx += skippy 12317 } 12318 } 12319 12320 if iNdEx > l { 12321 return io.ErrUnexpectedEOF 12322 } 12323 return nil 12324 } 12325 func (m *BeginStreamExecuteResponse) UnmarshalVT(dAtA []byte) error { 12326 l := len(dAtA) 12327 iNdEx := 0 12328 for iNdEx < l { 12329 preIndex := iNdEx 12330 var wire uint64 12331 for shift := uint(0); ; shift += 7 { 12332 if shift >= 64 { 12333 return ErrIntOverflow 12334 } 12335 if iNdEx >= l { 12336 return io.ErrUnexpectedEOF 12337 } 12338 b := dAtA[iNdEx] 12339 iNdEx++ 12340 wire |= uint64(b&0x7F) << shift 12341 if b < 0x80 { 12342 break 12343 } 12344 } 12345 fieldNum := int32(wire >> 3) 12346 wireType := int(wire & 0x7) 12347 if wireType == 4 { 12348 return fmt.Errorf("proto: BeginStreamExecuteResponse: wiretype end group for non-group") 12349 } 12350 if fieldNum <= 0 { 12351 return fmt.Errorf("proto: BeginStreamExecuteResponse: illegal tag %d (wire type %d)", fieldNum, wire) 12352 } 12353 switch fieldNum { 12354 case 1: 12355 if wireType != 2 { 12356 return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) 12357 } 12358 var msglen int 12359 for shift := uint(0); ; shift += 7 { 12360 if shift >= 64 { 12361 return ErrIntOverflow 12362 } 12363 if iNdEx >= l { 12364 return io.ErrUnexpectedEOF 12365 } 12366 b := dAtA[iNdEx] 12367 iNdEx++ 12368 msglen |= int(b&0x7F) << shift 12369 if b < 0x80 { 12370 break 12371 } 12372 } 12373 if msglen < 0 { 12374 return ErrInvalidLength 12375 } 12376 postIndex := iNdEx + msglen 12377 if postIndex < 0 { 12378 return ErrInvalidLength 12379 } 12380 if postIndex > l { 12381 return io.ErrUnexpectedEOF 12382 } 12383 if m.Error == nil { 12384 m.Error = &vtrpc.RPCError{} 12385 } 12386 if err := m.Error.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 12387 return err 12388 } 12389 iNdEx = postIndex 12390 case 2: 12391 if wireType != 2 { 12392 return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) 12393 } 12394 var msglen int 12395 for shift := uint(0); ; shift += 7 { 12396 if shift >= 64 { 12397 return ErrIntOverflow 12398 } 12399 if iNdEx >= l { 12400 return io.ErrUnexpectedEOF 12401 } 12402 b := dAtA[iNdEx] 12403 iNdEx++ 12404 msglen |= int(b&0x7F) << shift 12405 if b < 0x80 { 12406 break 12407 } 12408 } 12409 if msglen < 0 { 12410 return ErrInvalidLength 12411 } 12412 postIndex := iNdEx + msglen 12413 if postIndex < 0 { 12414 return ErrInvalidLength 12415 } 12416 if postIndex > l { 12417 return io.ErrUnexpectedEOF 12418 } 12419 if m.Result == nil { 12420 m.Result = &QueryResult{} 12421 } 12422 if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 12423 return err 12424 } 12425 iNdEx = postIndex 12426 case 3: 12427 if wireType != 0 { 12428 return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType) 12429 } 12430 m.TransactionId = 0 12431 for shift := uint(0); ; shift += 7 { 12432 if shift >= 64 { 12433 return ErrIntOverflow 12434 } 12435 if iNdEx >= l { 12436 return io.ErrUnexpectedEOF 12437 } 12438 b := dAtA[iNdEx] 12439 iNdEx++ 12440 m.TransactionId |= int64(b&0x7F) << shift 12441 if b < 0x80 { 12442 break 12443 } 12444 } 12445 case 4: 12446 if wireType != 2 { 12447 return fmt.Errorf("proto: wrong wireType = %d for field TabletAlias", wireType) 12448 } 12449 var msglen int 12450 for shift := uint(0); ; shift += 7 { 12451 if shift >= 64 { 12452 return ErrIntOverflow 12453 } 12454 if iNdEx >= l { 12455 return io.ErrUnexpectedEOF 12456 } 12457 b := dAtA[iNdEx] 12458 iNdEx++ 12459 msglen |= int(b&0x7F) << shift 12460 if b < 0x80 { 12461 break 12462 } 12463 } 12464 if msglen < 0 { 12465 return ErrInvalidLength 12466 } 12467 postIndex := iNdEx + msglen 12468 if postIndex < 0 { 12469 return ErrInvalidLength 12470 } 12471 if postIndex > l { 12472 return io.ErrUnexpectedEOF 12473 } 12474 if m.TabletAlias == nil { 12475 m.TabletAlias = &topodata.TabletAlias{} 12476 } 12477 if err := m.TabletAlias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 12478 return err 12479 } 12480 iNdEx = postIndex 12481 default: 12482 iNdEx = preIndex 12483 skippy, err := skip(dAtA[iNdEx:]) 12484 if err != nil { 12485 return err 12486 } 12487 if (skippy < 0) || (iNdEx+skippy) < 0 { 12488 return ErrInvalidLength 12489 } 12490 if (iNdEx + skippy) > l { 12491 return io.ErrUnexpectedEOF 12492 } 12493 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 12494 iNdEx += skippy 12495 } 12496 } 12497 12498 if iNdEx > l { 12499 return io.ErrUnexpectedEOF 12500 } 12501 return nil 12502 } 12503 func (m *MessageStreamRequest) UnmarshalVT(dAtA []byte) error { 12504 l := len(dAtA) 12505 iNdEx := 0 12506 for iNdEx < l { 12507 preIndex := iNdEx 12508 var wire uint64 12509 for shift := uint(0); ; shift += 7 { 12510 if shift >= 64 { 12511 return ErrIntOverflow 12512 } 12513 if iNdEx >= l { 12514 return io.ErrUnexpectedEOF 12515 } 12516 b := dAtA[iNdEx] 12517 iNdEx++ 12518 wire |= uint64(b&0x7F) << shift 12519 if b < 0x80 { 12520 break 12521 } 12522 } 12523 fieldNum := int32(wire >> 3) 12524 wireType := int(wire & 0x7) 12525 if wireType == 4 { 12526 return fmt.Errorf("proto: MessageStreamRequest: wiretype end group for non-group") 12527 } 12528 if fieldNum <= 0 { 12529 return fmt.Errorf("proto: MessageStreamRequest: illegal tag %d (wire type %d)", fieldNum, wire) 12530 } 12531 switch fieldNum { 12532 case 1: 12533 if wireType != 2 { 12534 return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType) 12535 } 12536 var msglen int 12537 for shift := uint(0); ; shift += 7 { 12538 if shift >= 64 { 12539 return ErrIntOverflow 12540 } 12541 if iNdEx >= l { 12542 return io.ErrUnexpectedEOF 12543 } 12544 b := dAtA[iNdEx] 12545 iNdEx++ 12546 msglen |= int(b&0x7F) << shift 12547 if b < 0x80 { 12548 break 12549 } 12550 } 12551 if msglen < 0 { 12552 return ErrInvalidLength 12553 } 12554 postIndex := iNdEx + msglen 12555 if postIndex < 0 { 12556 return ErrInvalidLength 12557 } 12558 if postIndex > l { 12559 return io.ErrUnexpectedEOF 12560 } 12561 if m.EffectiveCallerId == nil { 12562 m.EffectiveCallerId = &vtrpc.CallerID{} 12563 } 12564 if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 12565 return err 12566 } 12567 iNdEx = postIndex 12568 case 2: 12569 if wireType != 2 { 12570 return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType) 12571 } 12572 var msglen int 12573 for shift := uint(0); ; shift += 7 { 12574 if shift >= 64 { 12575 return ErrIntOverflow 12576 } 12577 if iNdEx >= l { 12578 return io.ErrUnexpectedEOF 12579 } 12580 b := dAtA[iNdEx] 12581 iNdEx++ 12582 msglen |= int(b&0x7F) << shift 12583 if b < 0x80 { 12584 break 12585 } 12586 } 12587 if msglen < 0 { 12588 return ErrInvalidLength 12589 } 12590 postIndex := iNdEx + msglen 12591 if postIndex < 0 { 12592 return ErrInvalidLength 12593 } 12594 if postIndex > l { 12595 return io.ErrUnexpectedEOF 12596 } 12597 if m.ImmediateCallerId == nil { 12598 m.ImmediateCallerId = &VTGateCallerID{} 12599 } 12600 if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 12601 return err 12602 } 12603 iNdEx = postIndex 12604 case 3: 12605 if wireType != 2 { 12606 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 12607 } 12608 var msglen int 12609 for shift := uint(0); ; shift += 7 { 12610 if shift >= 64 { 12611 return ErrIntOverflow 12612 } 12613 if iNdEx >= l { 12614 return io.ErrUnexpectedEOF 12615 } 12616 b := dAtA[iNdEx] 12617 iNdEx++ 12618 msglen |= int(b&0x7F) << shift 12619 if b < 0x80 { 12620 break 12621 } 12622 } 12623 if msglen < 0 { 12624 return ErrInvalidLength 12625 } 12626 postIndex := iNdEx + msglen 12627 if postIndex < 0 { 12628 return ErrInvalidLength 12629 } 12630 if postIndex > l { 12631 return io.ErrUnexpectedEOF 12632 } 12633 if m.Target == nil { 12634 m.Target = &Target{} 12635 } 12636 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 12637 return err 12638 } 12639 iNdEx = postIndex 12640 case 4: 12641 if wireType != 2 { 12642 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) 12643 } 12644 var stringLen uint64 12645 for shift := uint(0); ; shift += 7 { 12646 if shift >= 64 { 12647 return ErrIntOverflow 12648 } 12649 if iNdEx >= l { 12650 return io.ErrUnexpectedEOF 12651 } 12652 b := dAtA[iNdEx] 12653 iNdEx++ 12654 stringLen |= uint64(b&0x7F) << shift 12655 if b < 0x80 { 12656 break 12657 } 12658 } 12659 intStringLen := int(stringLen) 12660 if intStringLen < 0 { 12661 return ErrInvalidLength 12662 } 12663 postIndex := iNdEx + intStringLen 12664 if postIndex < 0 { 12665 return ErrInvalidLength 12666 } 12667 if postIndex > l { 12668 return io.ErrUnexpectedEOF 12669 } 12670 m.Name = string(dAtA[iNdEx:postIndex]) 12671 iNdEx = postIndex 12672 default: 12673 iNdEx = preIndex 12674 skippy, err := skip(dAtA[iNdEx:]) 12675 if err != nil { 12676 return err 12677 } 12678 if (skippy < 0) || (iNdEx+skippy) < 0 { 12679 return ErrInvalidLength 12680 } 12681 if (iNdEx + skippy) > l { 12682 return io.ErrUnexpectedEOF 12683 } 12684 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 12685 iNdEx += skippy 12686 } 12687 } 12688 12689 if iNdEx > l { 12690 return io.ErrUnexpectedEOF 12691 } 12692 return nil 12693 } 12694 func (m *MessageStreamResponse) UnmarshalVT(dAtA []byte) error { 12695 l := len(dAtA) 12696 iNdEx := 0 12697 for iNdEx < l { 12698 preIndex := iNdEx 12699 var wire uint64 12700 for shift := uint(0); ; shift += 7 { 12701 if shift >= 64 { 12702 return ErrIntOverflow 12703 } 12704 if iNdEx >= l { 12705 return io.ErrUnexpectedEOF 12706 } 12707 b := dAtA[iNdEx] 12708 iNdEx++ 12709 wire |= uint64(b&0x7F) << shift 12710 if b < 0x80 { 12711 break 12712 } 12713 } 12714 fieldNum := int32(wire >> 3) 12715 wireType := int(wire & 0x7) 12716 if wireType == 4 { 12717 return fmt.Errorf("proto: MessageStreamResponse: wiretype end group for non-group") 12718 } 12719 if fieldNum <= 0 { 12720 return fmt.Errorf("proto: MessageStreamResponse: illegal tag %d (wire type %d)", fieldNum, wire) 12721 } 12722 switch fieldNum { 12723 case 1: 12724 if wireType != 2 { 12725 return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) 12726 } 12727 var msglen int 12728 for shift := uint(0); ; shift += 7 { 12729 if shift >= 64 { 12730 return ErrIntOverflow 12731 } 12732 if iNdEx >= l { 12733 return io.ErrUnexpectedEOF 12734 } 12735 b := dAtA[iNdEx] 12736 iNdEx++ 12737 msglen |= int(b&0x7F) << shift 12738 if b < 0x80 { 12739 break 12740 } 12741 } 12742 if msglen < 0 { 12743 return ErrInvalidLength 12744 } 12745 postIndex := iNdEx + msglen 12746 if postIndex < 0 { 12747 return ErrInvalidLength 12748 } 12749 if postIndex > l { 12750 return io.ErrUnexpectedEOF 12751 } 12752 if m.Result == nil { 12753 m.Result = &QueryResult{} 12754 } 12755 if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 12756 return err 12757 } 12758 iNdEx = postIndex 12759 default: 12760 iNdEx = preIndex 12761 skippy, err := skip(dAtA[iNdEx:]) 12762 if err != nil { 12763 return err 12764 } 12765 if (skippy < 0) || (iNdEx+skippy) < 0 { 12766 return ErrInvalidLength 12767 } 12768 if (iNdEx + skippy) > l { 12769 return io.ErrUnexpectedEOF 12770 } 12771 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 12772 iNdEx += skippy 12773 } 12774 } 12775 12776 if iNdEx > l { 12777 return io.ErrUnexpectedEOF 12778 } 12779 return nil 12780 } 12781 func (m *MessageAckRequest) UnmarshalVT(dAtA []byte) error { 12782 l := len(dAtA) 12783 iNdEx := 0 12784 for iNdEx < l { 12785 preIndex := iNdEx 12786 var wire uint64 12787 for shift := uint(0); ; shift += 7 { 12788 if shift >= 64 { 12789 return ErrIntOverflow 12790 } 12791 if iNdEx >= l { 12792 return io.ErrUnexpectedEOF 12793 } 12794 b := dAtA[iNdEx] 12795 iNdEx++ 12796 wire |= uint64(b&0x7F) << shift 12797 if b < 0x80 { 12798 break 12799 } 12800 } 12801 fieldNum := int32(wire >> 3) 12802 wireType := int(wire & 0x7) 12803 if wireType == 4 { 12804 return fmt.Errorf("proto: MessageAckRequest: wiretype end group for non-group") 12805 } 12806 if fieldNum <= 0 { 12807 return fmt.Errorf("proto: MessageAckRequest: illegal tag %d (wire type %d)", fieldNum, wire) 12808 } 12809 switch fieldNum { 12810 case 1: 12811 if wireType != 2 { 12812 return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType) 12813 } 12814 var msglen int 12815 for shift := uint(0); ; shift += 7 { 12816 if shift >= 64 { 12817 return ErrIntOverflow 12818 } 12819 if iNdEx >= l { 12820 return io.ErrUnexpectedEOF 12821 } 12822 b := dAtA[iNdEx] 12823 iNdEx++ 12824 msglen |= int(b&0x7F) << shift 12825 if b < 0x80 { 12826 break 12827 } 12828 } 12829 if msglen < 0 { 12830 return ErrInvalidLength 12831 } 12832 postIndex := iNdEx + msglen 12833 if postIndex < 0 { 12834 return ErrInvalidLength 12835 } 12836 if postIndex > l { 12837 return io.ErrUnexpectedEOF 12838 } 12839 if m.EffectiveCallerId == nil { 12840 m.EffectiveCallerId = &vtrpc.CallerID{} 12841 } 12842 if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 12843 return err 12844 } 12845 iNdEx = postIndex 12846 case 2: 12847 if wireType != 2 { 12848 return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType) 12849 } 12850 var msglen int 12851 for shift := uint(0); ; shift += 7 { 12852 if shift >= 64 { 12853 return ErrIntOverflow 12854 } 12855 if iNdEx >= l { 12856 return io.ErrUnexpectedEOF 12857 } 12858 b := dAtA[iNdEx] 12859 iNdEx++ 12860 msglen |= int(b&0x7F) << shift 12861 if b < 0x80 { 12862 break 12863 } 12864 } 12865 if msglen < 0 { 12866 return ErrInvalidLength 12867 } 12868 postIndex := iNdEx + msglen 12869 if postIndex < 0 { 12870 return ErrInvalidLength 12871 } 12872 if postIndex > l { 12873 return io.ErrUnexpectedEOF 12874 } 12875 if m.ImmediateCallerId == nil { 12876 m.ImmediateCallerId = &VTGateCallerID{} 12877 } 12878 if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 12879 return err 12880 } 12881 iNdEx = postIndex 12882 case 3: 12883 if wireType != 2 { 12884 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 12885 } 12886 var msglen int 12887 for shift := uint(0); ; shift += 7 { 12888 if shift >= 64 { 12889 return ErrIntOverflow 12890 } 12891 if iNdEx >= l { 12892 return io.ErrUnexpectedEOF 12893 } 12894 b := dAtA[iNdEx] 12895 iNdEx++ 12896 msglen |= int(b&0x7F) << shift 12897 if b < 0x80 { 12898 break 12899 } 12900 } 12901 if msglen < 0 { 12902 return ErrInvalidLength 12903 } 12904 postIndex := iNdEx + msglen 12905 if postIndex < 0 { 12906 return ErrInvalidLength 12907 } 12908 if postIndex > l { 12909 return io.ErrUnexpectedEOF 12910 } 12911 if m.Target == nil { 12912 m.Target = &Target{} 12913 } 12914 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 12915 return err 12916 } 12917 iNdEx = postIndex 12918 case 4: 12919 if wireType != 2 { 12920 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) 12921 } 12922 var stringLen uint64 12923 for shift := uint(0); ; shift += 7 { 12924 if shift >= 64 { 12925 return ErrIntOverflow 12926 } 12927 if iNdEx >= l { 12928 return io.ErrUnexpectedEOF 12929 } 12930 b := dAtA[iNdEx] 12931 iNdEx++ 12932 stringLen |= uint64(b&0x7F) << shift 12933 if b < 0x80 { 12934 break 12935 } 12936 } 12937 intStringLen := int(stringLen) 12938 if intStringLen < 0 { 12939 return ErrInvalidLength 12940 } 12941 postIndex := iNdEx + intStringLen 12942 if postIndex < 0 { 12943 return ErrInvalidLength 12944 } 12945 if postIndex > l { 12946 return io.ErrUnexpectedEOF 12947 } 12948 m.Name = string(dAtA[iNdEx:postIndex]) 12949 iNdEx = postIndex 12950 case 5: 12951 if wireType != 2 { 12952 return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType) 12953 } 12954 var msglen int 12955 for shift := uint(0); ; shift += 7 { 12956 if shift >= 64 { 12957 return ErrIntOverflow 12958 } 12959 if iNdEx >= l { 12960 return io.ErrUnexpectedEOF 12961 } 12962 b := dAtA[iNdEx] 12963 iNdEx++ 12964 msglen |= int(b&0x7F) << shift 12965 if b < 0x80 { 12966 break 12967 } 12968 } 12969 if msglen < 0 { 12970 return ErrInvalidLength 12971 } 12972 postIndex := iNdEx + msglen 12973 if postIndex < 0 { 12974 return ErrInvalidLength 12975 } 12976 if postIndex > l { 12977 return io.ErrUnexpectedEOF 12978 } 12979 m.Ids = append(m.Ids, &Value{}) 12980 if err := m.Ids[len(m.Ids)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 12981 return err 12982 } 12983 iNdEx = postIndex 12984 default: 12985 iNdEx = preIndex 12986 skippy, err := skip(dAtA[iNdEx:]) 12987 if err != nil { 12988 return err 12989 } 12990 if (skippy < 0) || (iNdEx+skippy) < 0 { 12991 return ErrInvalidLength 12992 } 12993 if (iNdEx + skippy) > l { 12994 return io.ErrUnexpectedEOF 12995 } 12996 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 12997 iNdEx += skippy 12998 } 12999 } 13000 13001 if iNdEx > l { 13002 return io.ErrUnexpectedEOF 13003 } 13004 return nil 13005 } 13006 func (m *MessageAckResponse) UnmarshalVT(dAtA []byte) error { 13007 l := len(dAtA) 13008 iNdEx := 0 13009 for iNdEx < l { 13010 preIndex := iNdEx 13011 var wire uint64 13012 for shift := uint(0); ; shift += 7 { 13013 if shift >= 64 { 13014 return ErrIntOverflow 13015 } 13016 if iNdEx >= l { 13017 return io.ErrUnexpectedEOF 13018 } 13019 b := dAtA[iNdEx] 13020 iNdEx++ 13021 wire |= uint64(b&0x7F) << shift 13022 if b < 0x80 { 13023 break 13024 } 13025 } 13026 fieldNum := int32(wire >> 3) 13027 wireType := int(wire & 0x7) 13028 if wireType == 4 { 13029 return fmt.Errorf("proto: MessageAckResponse: wiretype end group for non-group") 13030 } 13031 if fieldNum <= 0 { 13032 return fmt.Errorf("proto: MessageAckResponse: illegal tag %d (wire type %d)", fieldNum, wire) 13033 } 13034 switch fieldNum { 13035 case 1: 13036 if wireType != 2 { 13037 return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) 13038 } 13039 var msglen int 13040 for shift := uint(0); ; shift += 7 { 13041 if shift >= 64 { 13042 return ErrIntOverflow 13043 } 13044 if iNdEx >= l { 13045 return io.ErrUnexpectedEOF 13046 } 13047 b := dAtA[iNdEx] 13048 iNdEx++ 13049 msglen |= int(b&0x7F) << shift 13050 if b < 0x80 { 13051 break 13052 } 13053 } 13054 if msglen < 0 { 13055 return ErrInvalidLength 13056 } 13057 postIndex := iNdEx + msglen 13058 if postIndex < 0 { 13059 return ErrInvalidLength 13060 } 13061 if postIndex > l { 13062 return io.ErrUnexpectedEOF 13063 } 13064 if m.Result == nil { 13065 m.Result = &QueryResult{} 13066 } 13067 if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 13068 return err 13069 } 13070 iNdEx = postIndex 13071 default: 13072 iNdEx = preIndex 13073 skippy, err := skip(dAtA[iNdEx:]) 13074 if err != nil { 13075 return err 13076 } 13077 if (skippy < 0) || (iNdEx+skippy) < 0 { 13078 return ErrInvalidLength 13079 } 13080 if (iNdEx + skippy) > l { 13081 return io.ErrUnexpectedEOF 13082 } 13083 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 13084 iNdEx += skippy 13085 } 13086 } 13087 13088 if iNdEx > l { 13089 return io.ErrUnexpectedEOF 13090 } 13091 return nil 13092 } 13093 func (m *ReserveExecuteRequest) UnmarshalVT(dAtA []byte) error { 13094 l := len(dAtA) 13095 iNdEx := 0 13096 for iNdEx < l { 13097 preIndex := iNdEx 13098 var wire uint64 13099 for shift := uint(0); ; shift += 7 { 13100 if shift >= 64 { 13101 return ErrIntOverflow 13102 } 13103 if iNdEx >= l { 13104 return io.ErrUnexpectedEOF 13105 } 13106 b := dAtA[iNdEx] 13107 iNdEx++ 13108 wire |= uint64(b&0x7F) << shift 13109 if b < 0x80 { 13110 break 13111 } 13112 } 13113 fieldNum := int32(wire >> 3) 13114 wireType := int(wire & 0x7) 13115 if wireType == 4 { 13116 return fmt.Errorf("proto: ReserveExecuteRequest: wiretype end group for non-group") 13117 } 13118 if fieldNum <= 0 { 13119 return fmt.Errorf("proto: ReserveExecuteRequest: illegal tag %d (wire type %d)", fieldNum, wire) 13120 } 13121 switch fieldNum { 13122 case 1: 13123 if wireType != 2 { 13124 return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType) 13125 } 13126 var msglen int 13127 for shift := uint(0); ; shift += 7 { 13128 if shift >= 64 { 13129 return ErrIntOverflow 13130 } 13131 if iNdEx >= l { 13132 return io.ErrUnexpectedEOF 13133 } 13134 b := dAtA[iNdEx] 13135 iNdEx++ 13136 msglen |= int(b&0x7F) << shift 13137 if b < 0x80 { 13138 break 13139 } 13140 } 13141 if msglen < 0 { 13142 return ErrInvalidLength 13143 } 13144 postIndex := iNdEx + msglen 13145 if postIndex < 0 { 13146 return ErrInvalidLength 13147 } 13148 if postIndex > l { 13149 return io.ErrUnexpectedEOF 13150 } 13151 if m.EffectiveCallerId == nil { 13152 m.EffectiveCallerId = &vtrpc.CallerID{} 13153 } 13154 if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 13155 return err 13156 } 13157 iNdEx = postIndex 13158 case 2: 13159 if wireType != 2 { 13160 return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType) 13161 } 13162 var msglen int 13163 for shift := uint(0); ; shift += 7 { 13164 if shift >= 64 { 13165 return ErrIntOverflow 13166 } 13167 if iNdEx >= l { 13168 return io.ErrUnexpectedEOF 13169 } 13170 b := dAtA[iNdEx] 13171 iNdEx++ 13172 msglen |= int(b&0x7F) << shift 13173 if b < 0x80 { 13174 break 13175 } 13176 } 13177 if msglen < 0 { 13178 return ErrInvalidLength 13179 } 13180 postIndex := iNdEx + msglen 13181 if postIndex < 0 { 13182 return ErrInvalidLength 13183 } 13184 if postIndex > l { 13185 return io.ErrUnexpectedEOF 13186 } 13187 if m.ImmediateCallerId == nil { 13188 m.ImmediateCallerId = &VTGateCallerID{} 13189 } 13190 if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 13191 return err 13192 } 13193 iNdEx = postIndex 13194 case 3: 13195 if wireType != 2 { 13196 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 13197 } 13198 var msglen int 13199 for shift := uint(0); ; shift += 7 { 13200 if shift >= 64 { 13201 return ErrIntOverflow 13202 } 13203 if iNdEx >= l { 13204 return io.ErrUnexpectedEOF 13205 } 13206 b := dAtA[iNdEx] 13207 iNdEx++ 13208 msglen |= int(b&0x7F) << shift 13209 if b < 0x80 { 13210 break 13211 } 13212 } 13213 if msglen < 0 { 13214 return ErrInvalidLength 13215 } 13216 postIndex := iNdEx + msglen 13217 if postIndex < 0 { 13218 return ErrInvalidLength 13219 } 13220 if postIndex > l { 13221 return io.ErrUnexpectedEOF 13222 } 13223 if m.Target == nil { 13224 m.Target = &Target{} 13225 } 13226 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 13227 return err 13228 } 13229 iNdEx = postIndex 13230 case 4: 13231 if wireType != 2 { 13232 return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) 13233 } 13234 var msglen int 13235 for shift := uint(0); ; shift += 7 { 13236 if shift >= 64 { 13237 return ErrIntOverflow 13238 } 13239 if iNdEx >= l { 13240 return io.ErrUnexpectedEOF 13241 } 13242 b := dAtA[iNdEx] 13243 iNdEx++ 13244 msglen |= int(b&0x7F) << shift 13245 if b < 0x80 { 13246 break 13247 } 13248 } 13249 if msglen < 0 { 13250 return ErrInvalidLength 13251 } 13252 postIndex := iNdEx + msglen 13253 if postIndex < 0 { 13254 return ErrInvalidLength 13255 } 13256 if postIndex > l { 13257 return io.ErrUnexpectedEOF 13258 } 13259 if m.Query == nil { 13260 m.Query = &BoundQuery{} 13261 } 13262 if err := m.Query.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 13263 return err 13264 } 13265 iNdEx = postIndex 13266 case 5: 13267 if wireType != 0 { 13268 return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType) 13269 } 13270 m.TransactionId = 0 13271 for shift := uint(0); ; shift += 7 { 13272 if shift >= 64 { 13273 return ErrIntOverflow 13274 } 13275 if iNdEx >= l { 13276 return io.ErrUnexpectedEOF 13277 } 13278 b := dAtA[iNdEx] 13279 iNdEx++ 13280 m.TransactionId |= int64(b&0x7F) << shift 13281 if b < 0x80 { 13282 break 13283 } 13284 } 13285 case 6: 13286 if wireType != 2 { 13287 return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType) 13288 } 13289 var msglen int 13290 for shift := uint(0); ; shift += 7 { 13291 if shift >= 64 { 13292 return ErrIntOverflow 13293 } 13294 if iNdEx >= l { 13295 return io.ErrUnexpectedEOF 13296 } 13297 b := dAtA[iNdEx] 13298 iNdEx++ 13299 msglen |= int(b&0x7F) << shift 13300 if b < 0x80 { 13301 break 13302 } 13303 } 13304 if msglen < 0 { 13305 return ErrInvalidLength 13306 } 13307 postIndex := iNdEx + msglen 13308 if postIndex < 0 { 13309 return ErrInvalidLength 13310 } 13311 if postIndex > l { 13312 return io.ErrUnexpectedEOF 13313 } 13314 if m.Options == nil { 13315 m.Options = &ExecuteOptions{} 13316 } 13317 if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 13318 return err 13319 } 13320 iNdEx = postIndex 13321 case 7: 13322 if wireType != 2 { 13323 return fmt.Errorf("proto: wrong wireType = %d for field PreQueries", wireType) 13324 } 13325 var stringLen uint64 13326 for shift := uint(0); ; shift += 7 { 13327 if shift >= 64 { 13328 return ErrIntOverflow 13329 } 13330 if iNdEx >= l { 13331 return io.ErrUnexpectedEOF 13332 } 13333 b := dAtA[iNdEx] 13334 iNdEx++ 13335 stringLen |= uint64(b&0x7F) << shift 13336 if b < 0x80 { 13337 break 13338 } 13339 } 13340 intStringLen := int(stringLen) 13341 if intStringLen < 0 { 13342 return ErrInvalidLength 13343 } 13344 postIndex := iNdEx + intStringLen 13345 if postIndex < 0 { 13346 return ErrInvalidLength 13347 } 13348 if postIndex > l { 13349 return io.ErrUnexpectedEOF 13350 } 13351 m.PreQueries = append(m.PreQueries, string(dAtA[iNdEx:postIndex])) 13352 iNdEx = postIndex 13353 default: 13354 iNdEx = preIndex 13355 skippy, err := skip(dAtA[iNdEx:]) 13356 if err != nil { 13357 return err 13358 } 13359 if (skippy < 0) || (iNdEx+skippy) < 0 { 13360 return ErrInvalidLength 13361 } 13362 if (iNdEx + skippy) > l { 13363 return io.ErrUnexpectedEOF 13364 } 13365 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 13366 iNdEx += skippy 13367 } 13368 } 13369 13370 if iNdEx > l { 13371 return io.ErrUnexpectedEOF 13372 } 13373 return nil 13374 } 13375 func (m *ReserveExecuteResponse) UnmarshalVT(dAtA []byte) error { 13376 l := len(dAtA) 13377 iNdEx := 0 13378 for iNdEx < l { 13379 preIndex := iNdEx 13380 var wire uint64 13381 for shift := uint(0); ; shift += 7 { 13382 if shift >= 64 { 13383 return ErrIntOverflow 13384 } 13385 if iNdEx >= l { 13386 return io.ErrUnexpectedEOF 13387 } 13388 b := dAtA[iNdEx] 13389 iNdEx++ 13390 wire |= uint64(b&0x7F) << shift 13391 if b < 0x80 { 13392 break 13393 } 13394 } 13395 fieldNum := int32(wire >> 3) 13396 wireType := int(wire & 0x7) 13397 if wireType == 4 { 13398 return fmt.Errorf("proto: ReserveExecuteResponse: wiretype end group for non-group") 13399 } 13400 if fieldNum <= 0 { 13401 return fmt.Errorf("proto: ReserveExecuteResponse: illegal tag %d (wire type %d)", fieldNum, wire) 13402 } 13403 switch fieldNum { 13404 case 1: 13405 if wireType != 2 { 13406 return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) 13407 } 13408 var msglen int 13409 for shift := uint(0); ; shift += 7 { 13410 if shift >= 64 { 13411 return ErrIntOverflow 13412 } 13413 if iNdEx >= l { 13414 return io.ErrUnexpectedEOF 13415 } 13416 b := dAtA[iNdEx] 13417 iNdEx++ 13418 msglen |= int(b&0x7F) << shift 13419 if b < 0x80 { 13420 break 13421 } 13422 } 13423 if msglen < 0 { 13424 return ErrInvalidLength 13425 } 13426 postIndex := iNdEx + msglen 13427 if postIndex < 0 { 13428 return ErrInvalidLength 13429 } 13430 if postIndex > l { 13431 return io.ErrUnexpectedEOF 13432 } 13433 if m.Error == nil { 13434 m.Error = &vtrpc.RPCError{} 13435 } 13436 if err := m.Error.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 13437 return err 13438 } 13439 iNdEx = postIndex 13440 case 2: 13441 if wireType != 2 { 13442 return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) 13443 } 13444 var msglen int 13445 for shift := uint(0); ; shift += 7 { 13446 if shift >= 64 { 13447 return ErrIntOverflow 13448 } 13449 if iNdEx >= l { 13450 return io.ErrUnexpectedEOF 13451 } 13452 b := dAtA[iNdEx] 13453 iNdEx++ 13454 msglen |= int(b&0x7F) << shift 13455 if b < 0x80 { 13456 break 13457 } 13458 } 13459 if msglen < 0 { 13460 return ErrInvalidLength 13461 } 13462 postIndex := iNdEx + msglen 13463 if postIndex < 0 { 13464 return ErrInvalidLength 13465 } 13466 if postIndex > l { 13467 return io.ErrUnexpectedEOF 13468 } 13469 if m.Result == nil { 13470 m.Result = &QueryResult{} 13471 } 13472 if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 13473 return err 13474 } 13475 iNdEx = postIndex 13476 case 3: 13477 if wireType != 0 { 13478 return fmt.Errorf("proto: wrong wireType = %d for field ReservedId", wireType) 13479 } 13480 m.ReservedId = 0 13481 for shift := uint(0); ; shift += 7 { 13482 if shift >= 64 { 13483 return ErrIntOverflow 13484 } 13485 if iNdEx >= l { 13486 return io.ErrUnexpectedEOF 13487 } 13488 b := dAtA[iNdEx] 13489 iNdEx++ 13490 m.ReservedId |= int64(b&0x7F) << shift 13491 if b < 0x80 { 13492 break 13493 } 13494 } 13495 case 4: 13496 if wireType != 2 { 13497 return fmt.Errorf("proto: wrong wireType = %d for field TabletAlias", wireType) 13498 } 13499 var msglen int 13500 for shift := uint(0); ; shift += 7 { 13501 if shift >= 64 { 13502 return ErrIntOverflow 13503 } 13504 if iNdEx >= l { 13505 return io.ErrUnexpectedEOF 13506 } 13507 b := dAtA[iNdEx] 13508 iNdEx++ 13509 msglen |= int(b&0x7F) << shift 13510 if b < 0x80 { 13511 break 13512 } 13513 } 13514 if msglen < 0 { 13515 return ErrInvalidLength 13516 } 13517 postIndex := iNdEx + msglen 13518 if postIndex < 0 { 13519 return ErrInvalidLength 13520 } 13521 if postIndex > l { 13522 return io.ErrUnexpectedEOF 13523 } 13524 if m.TabletAlias == nil { 13525 m.TabletAlias = &topodata.TabletAlias{} 13526 } 13527 if err := m.TabletAlias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 13528 return err 13529 } 13530 iNdEx = postIndex 13531 default: 13532 iNdEx = preIndex 13533 skippy, err := skip(dAtA[iNdEx:]) 13534 if err != nil { 13535 return err 13536 } 13537 if (skippy < 0) || (iNdEx+skippy) < 0 { 13538 return ErrInvalidLength 13539 } 13540 if (iNdEx + skippy) > l { 13541 return io.ErrUnexpectedEOF 13542 } 13543 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 13544 iNdEx += skippy 13545 } 13546 } 13547 13548 if iNdEx > l { 13549 return io.ErrUnexpectedEOF 13550 } 13551 return nil 13552 } 13553 func (m *ReserveStreamExecuteRequest) UnmarshalVT(dAtA []byte) error { 13554 l := len(dAtA) 13555 iNdEx := 0 13556 for iNdEx < l { 13557 preIndex := iNdEx 13558 var wire uint64 13559 for shift := uint(0); ; shift += 7 { 13560 if shift >= 64 { 13561 return ErrIntOverflow 13562 } 13563 if iNdEx >= l { 13564 return io.ErrUnexpectedEOF 13565 } 13566 b := dAtA[iNdEx] 13567 iNdEx++ 13568 wire |= uint64(b&0x7F) << shift 13569 if b < 0x80 { 13570 break 13571 } 13572 } 13573 fieldNum := int32(wire >> 3) 13574 wireType := int(wire & 0x7) 13575 if wireType == 4 { 13576 return fmt.Errorf("proto: ReserveStreamExecuteRequest: wiretype end group for non-group") 13577 } 13578 if fieldNum <= 0 { 13579 return fmt.Errorf("proto: ReserveStreamExecuteRequest: illegal tag %d (wire type %d)", fieldNum, wire) 13580 } 13581 switch fieldNum { 13582 case 1: 13583 if wireType != 2 { 13584 return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType) 13585 } 13586 var msglen int 13587 for shift := uint(0); ; shift += 7 { 13588 if shift >= 64 { 13589 return ErrIntOverflow 13590 } 13591 if iNdEx >= l { 13592 return io.ErrUnexpectedEOF 13593 } 13594 b := dAtA[iNdEx] 13595 iNdEx++ 13596 msglen |= int(b&0x7F) << shift 13597 if b < 0x80 { 13598 break 13599 } 13600 } 13601 if msglen < 0 { 13602 return ErrInvalidLength 13603 } 13604 postIndex := iNdEx + msglen 13605 if postIndex < 0 { 13606 return ErrInvalidLength 13607 } 13608 if postIndex > l { 13609 return io.ErrUnexpectedEOF 13610 } 13611 if m.EffectiveCallerId == nil { 13612 m.EffectiveCallerId = &vtrpc.CallerID{} 13613 } 13614 if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 13615 return err 13616 } 13617 iNdEx = postIndex 13618 case 2: 13619 if wireType != 2 { 13620 return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType) 13621 } 13622 var msglen int 13623 for shift := uint(0); ; shift += 7 { 13624 if shift >= 64 { 13625 return ErrIntOverflow 13626 } 13627 if iNdEx >= l { 13628 return io.ErrUnexpectedEOF 13629 } 13630 b := dAtA[iNdEx] 13631 iNdEx++ 13632 msglen |= int(b&0x7F) << shift 13633 if b < 0x80 { 13634 break 13635 } 13636 } 13637 if msglen < 0 { 13638 return ErrInvalidLength 13639 } 13640 postIndex := iNdEx + msglen 13641 if postIndex < 0 { 13642 return ErrInvalidLength 13643 } 13644 if postIndex > l { 13645 return io.ErrUnexpectedEOF 13646 } 13647 if m.ImmediateCallerId == nil { 13648 m.ImmediateCallerId = &VTGateCallerID{} 13649 } 13650 if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 13651 return err 13652 } 13653 iNdEx = postIndex 13654 case 3: 13655 if wireType != 2 { 13656 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 13657 } 13658 var msglen int 13659 for shift := uint(0); ; shift += 7 { 13660 if shift >= 64 { 13661 return ErrIntOverflow 13662 } 13663 if iNdEx >= l { 13664 return io.ErrUnexpectedEOF 13665 } 13666 b := dAtA[iNdEx] 13667 iNdEx++ 13668 msglen |= int(b&0x7F) << shift 13669 if b < 0x80 { 13670 break 13671 } 13672 } 13673 if msglen < 0 { 13674 return ErrInvalidLength 13675 } 13676 postIndex := iNdEx + msglen 13677 if postIndex < 0 { 13678 return ErrInvalidLength 13679 } 13680 if postIndex > l { 13681 return io.ErrUnexpectedEOF 13682 } 13683 if m.Target == nil { 13684 m.Target = &Target{} 13685 } 13686 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 13687 return err 13688 } 13689 iNdEx = postIndex 13690 case 4: 13691 if wireType != 2 { 13692 return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) 13693 } 13694 var msglen int 13695 for shift := uint(0); ; shift += 7 { 13696 if shift >= 64 { 13697 return ErrIntOverflow 13698 } 13699 if iNdEx >= l { 13700 return io.ErrUnexpectedEOF 13701 } 13702 b := dAtA[iNdEx] 13703 iNdEx++ 13704 msglen |= int(b&0x7F) << shift 13705 if b < 0x80 { 13706 break 13707 } 13708 } 13709 if msglen < 0 { 13710 return ErrInvalidLength 13711 } 13712 postIndex := iNdEx + msglen 13713 if postIndex < 0 { 13714 return ErrInvalidLength 13715 } 13716 if postIndex > l { 13717 return io.ErrUnexpectedEOF 13718 } 13719 if m.Query == nil { 13720 m.Query = &BoundQuery{} 13721 } 13722 if err := m.Query.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 13723 return err 13724 } 13725 iNdEx = postIndex 13726 case 5: 13727 if wireType != 2 { 13728 return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType) 13729 } 13730 var msglen int 13731 for shift := uint(0); ; shift += 7 { 13732 if shift >= 64 { 13733 return ErrIntOverflow 13734 } 13735 if iNdEx >= l { 13736 return io.ErrUnexpectedEOF 13737 } 13738 b := dAtA[iNdEx] 13739 iNdEx++ 13740 msglen |= int(b&0x7F) << shift 13741 if b < 0x80 { 13742 break 13743 } 13744 } 13745 if msglen < 0 { 13746 return ErrInvalidLength 13747 } 13748 postIndex := iNdEx + msglen 13749 if postIndex < 0 { 13750 return ErrInvalidLength 13751 } 13752 if postIndex > l { 13753 return io.ErrUnexpectedEOF 13754 } 13755 if m.Options == nil { 13756 m.Options = &ExecuteOptions{} 13757 } 13758 if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 13759 return err 13760 } 13761 iNdEx = postIndex 13762 case 6: 13763 if wireType != 0 { 13764 return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType) 13765 } 13766 m.TransactionId = 0 13767 for shift := uint(0); ; shift += 7 { 13768 if shift >= 64 { 13769 return ErrIntOverflow 13770 } 13771 if iNdEx >= l { 13772 return io.ErrUnexpectedEOF 13773 } 13774 b := dAtA[iNdEx] 13775 iNdEx++ 13776 m.TransactionId |= int64(b&0x7F) << shift 13777 if b < 0x80 { 13778 break 13779 } 13780 } 13781 case 7: 13782 if wireType != 2 { 13783 return fmt.Errorf("proto: wrong wireType = %d for field PreQueries", wireType) 13784 } 13785 var stringLen uint64 13786 for shift := uint(0); ; shift += 7 { 13787 if shift >= 64 { 13788 return ErrIntOverflow 13789 } 13790 if iNdEx >= l { 13791 return io.ErrUnexpectedEOF 13792 } 13793 b := dAtA[iNdEx] 13794 iNdEx++ 13795 stringLen |= uint64(b&0x7F) << shift 13796 if b < 0x80 { 13797 break 13798 } 13799 } 13800 intStringLen := int(stringLen) 13801 if intStringLen < 0 { 13802 return ErrInvalidLength 13803 } 13804 postIndex := iNdEx + intStringLen 13805 if postIndex < 0 { 13806 return ErrInvalidLength 13807 } 13808 if postIndex > l { 13809 return io.ErrUnexpectedEOF 13810 } 13811 m.PreQueries = append(m.PreQueries, string(dAtA[iNdEx:postIndex])) 13812 iNdEx = postIndex 13813 default: 13814 iNdEx = preIndex 13815 skippy, err := skip(dAtA[iNdEx:]) 13816 if err != nil { 13817 return err 13818 } 13819 if (skippy < 0) || (iNdEx+skippy) < 0 { 13820 return ErrInvalidLength 13821 } 13822 if (iNdEx + skippy) > l { 13823 return io.ErrUnexpectedEOF 13824 } 13825 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 13826 iNdEx += skippy 13827 } 13828 } 13829 13830 if iNdEx > l { 13831 return io.ErrUnexpectedEOF 13832 } 13833 return nil 13834 } 13835 func (m *ReserveStreamExecuteResponse) UnmarshalVT(dAtA []byte) error { 13836 l := len(dAtA) 13837 iNdEx := 0 13838 for iNdEx < l { 13839 preIndex := iNdEx 13840 var wire uint64 13841 for shift := uint(0); ; shift += 7 { 13842 if shift >= 64 { 13843 return ErrIntOverflow 13844 } 13845 if iNdEx >= l { 13846 return io.ErrUnexpectedEOF 13847 } 13848 b := dAtA[iNdEx] 13849 iNdEx++ 13850 wire |= uint64(b&0x7F) << shift 13851 if b < 0x80 { 13852 break 13853 } 13854 } 13855 fieldNum := int32(wire >> 3) 13856 wireType := int(wire & 0x7) 13857 if wireType == 4 { 13858 return fmt.Errorf("proto: ReserveStreamExecuteResponse: wiretype end group for non-group") 13859 } 13860 if fieldNum <= 0 { 13861 return fmt.Errorf("proto: ReserveStreamExecuteResponse: illegal tag %d (wire type %d)", fieldNum, wire) 13862 } 13863 switch fieldNum { 13864 case 1: 13865 if wireType != 2 { 13866 return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) 13867 } 13868 var msglen int 13869 for shift := uint(0); ; shift += 7 { 13870 if shift >= 64 { 13871 return ErrIntOverflow 13872 } 13873 if iNdEx >= l { 13874 return io.ErrUnexpectedEOF 13875 } 13876 b := dAtA[iNdEx] 13877 iNdEx++ 13878 msglen |= int(b&0x7F) << shift 13879 if b < 0x80 { 13880 break 13881 } 13882 } 13883 if msglen < 0 { 13884 return ErrInvalidLength 13885 } 13886 postIndex := iNdEx + msglen 13887 if postIndex < 0 { 13888 return ErrInvalidLength 13889 } 13890 if postIndex > l { 13891 return io.ErrUnexpectedEOF 13892 } 13893 if m.Error == nil { 13894 m.Error = &vtrpc.RPCError{} 13895 } 13896 if err := m.Error.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 13897 return err 13898 } 13899 iNdEx = postIndex 13900 case 2: 13901 if wireType != 2 { 13902 return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) 13903 } 13904 var msglen int 13905 for shift := uint(0); ; shift += 7 { 13906 if shift >= 64 { 13907 return ErrIntOverflow 13908 } 13909 if iNdEx >= l { 13910 return io.ErrUnexpectedEOF 13911 } 13912 b := dAtA[iNdEx] 13913 iNdEx++ 13914 msglen |= int(b&0x7F) << shift 13915 if b < 0x80 { 13916 break 13917 } 13918 } 13919 if msglen < 0 { 13920 return ErrInvalidLength 13921 } 13922 postIndex := iNdEx + msglen 13923 if postIndex < 0 { 13924 return ErrInvalidLength 13925 } 13926 if postIndex > l { 13927 return io.ErrUnexpectedEOF 13928 } 13929 if m.Result == nil { 13930 m.Result = &QueryResult{} 13931 } 13932 if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 13933 return err 13934 } 13935 iNdEx = postIndex 13936 case 3: 13937 if wireType != 0 { 13938 return fmt.Errorf("proto: wrong wireType = %d for field ReservedId", wireType) 13939 } 13940 m.ReservedId = 0 13941 for shift := uint(0); ; shift += 7 { 13942 if shift >= 64 { 13943 return ErrIntOverflow 13944 } 13945 if iNdEx >= l { 13946 return io.ErrUnexpectedEOF 13947 } 13948 b := dAtA[iNdEx] 13949 iNdEx++ 13950 m.ReservedId |= int64(b&0x7F) << shift 13951 if b < 0x80 { 13952 break 13953 } 13954 } 13955 case 4: 13956 if wireType != 2 { 13957 return fmt.Errorf("proto: wrong wireType = %d for field TabletAlias", wireType) 13958 } 13959 var msglen int 13960 for shift := uint(0); ; shift += 7 { 13961 if shift >= 64 { 13962 return ErrIntOverflow 13963 } 13964 if iNdEx >= l { 13965 return io.ErrUnexpectedEOF 13966 } 13967 b := dAtA[iNdEx] 13968 iNdEx++ 13969 msglen |= int(b&0x7F) << shift 13970 if b < 0x80 { 13971 break 13972 } 13973 } 13974 if msglen < 0 { 13975 return ErrInvalidLength 13976 } 13977 postIndex := iNdEx + msglen 13978 if postIndex < 0 { 13979 return ErrInvalidLength 13980 } 13981 if postIndex > l { 13982 return io.ErrUnexpectedEOF 13983 } 13984 if m.TabletAlias == nil { 13985 m.TabletAlias = &topodata.TabletAlias{} 13986 } 13987 if err := m.TabletAlias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 13988 return err 13989 } 13990 iNdEx = postIndex 13991 default: 13992 iNdEx = preIndex 13993 skippy, err := skip(dAtA[iNdEx:]) 13994 if err != nil { 13995 return err 13996 } 13997 if (skippy < 0) || (iNdEx+skippy) < 0 { 13998 return ErrInvalidLength 13999 } 14000 if (iNdEx + skippy) > l { 14001 return io.ErrUnexpectedEOF 14002 } 14003 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 14004 iNdEx += skippy 14005 } 14006 } 14007 14008 if iNdEx > l { 14009 return io.ErrUnexpectedEOF 14010 } 14011 return nil 14012 } 14013 func (m *ReserveBeginExecuteRequest) UnmarshalVT(dAtA []byte) error { 14014 l := len(dAtA) 14015 iNdEx := 0 14016 for iNdEx < l { 14017 preIndex := iNdEx 14018 var wire uint64 14019 for shift := uint(0); ; shift += 7 { 14020 if shift >= 64 { 14021 return ErrIntOverflow 14022 } 14023 if iNdEx >= l { 14024 return io.ErrUnexpectedEOF 14025 } 14026 b := dAtA[iNdEx] 14027 iNdEx++ 14028 wire |= uint64(b&0x7F) << shift 14029 if b < 0x80 { 14030 break 14031 } 14032 } 14033 fieldNum := int32(wire >> 3) 14034 wireType := int(wire & 0x7) 14035 if wireType == 4 { 14036 return fmt.Errorf("proto: ReserveBeginExecuteRequest: wiretype end group for non-group") 14037 } 14038 if fieldNum <= 0 { 14039 return fmt.Errorf("proto: ReserveBeginExecuteRequest: illegal tag %d (wire type %d)", fieldNum, wire) 14040 } 14041 switch fieldNum { 14042 case 1: 14043 if wireType != 2 { 14044 return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType) 14045 } 14046 var msglen int 14047 for shift := uint(0); ; shift += 7 { 14048 if shift >= 64 { 14049 return ErrIntOverflow 14050 } 14051 if iNdEx >= l { 14052 return io.ErrUnexpectedEOF 14053 } 14054 b := dAtA[iNdEx] 14055 iNdEx++ 14056 msglen |= int(b&0x7F) << shift 14057 if b < 0x80 { 14058 break 14059 } 14060 } 14061 if msglen < 0 { 14062 return ErrInvalidLength 14063 } 14064 postIndex := iNdEx + msglen 14065 if postIndex < 0 { 14066 return ErrInvalidLength 14067 } 14068 if postIndex > l { 14069 return io.ErrUnexpectedEOF 14070 } 14071 if m.EffectiveCallerId == nil { 14072 m.EffectiveCallerId = &vtrpc.CallerID{} 14073 } 14074 if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 14075 return err 14076 } 14077 iNdEx = postIndex 14078 case 2: 14079 if wireType != 2 { 14080 return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType) 14081 } 14082 var msglen int 14083 for shift := uint(0); ; shift += 7 { 14084 if shift >= 64 { 14085 return ErrIntOverflow 14086 } 14087 if iNdEx >= l { 14088 return io.ErrUnexpectedEOF 14089 } 14090 b := dAtA[iNdEx] 14091 iNdEx++ 14092 msglen |= int(b&0x7F) << shift 14093 if b < 0x80 { 14094 break 14095 } 14096 } 14097 if msglen < 0 { 14098 return ErrInvalidLength 14099 } 14100 postIndex := iNdEx + msglen 14101 if postIndex < 0 { 14102 return ErrInvalidLength 14103 } 14104 if postIndex > l { 14105 return io.ErrUnexpectedEOF 14106 } 14107 if m.ImmediateCallerId == nil { 14108 m.ImmediateCallerId = &VTGateCallerID{} 14109 } 14110 if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 14111 return err 14112 } 14113 iNdEx = postIndex 14114 case 3: 14115 if wireType != 2 { 14116 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 14117 } 14118 var msglen int 14119 for shift := uint(0); ; shift += 7 { 14120 if shift >= 64 { 14121 return ErrIntOverflow 14122 } 14123 if iNdEx >= l { 14124 return io.ErrUnexpectedEOF 14125 } 14126 b := dAtA[iNdEx] 14127 iNdEx++ 14128 msglen |= int(b&0x7F) << shift 14129 if b < 0x80 { 14130 break 14131 } 14132 } 14133 if msglen < 0 { 14134 return ErrInvalidLength 14135 } 14136 postIndex := iNdEx + msglen 14137 if postIndex < 0 { 14138 return ErrInvalidLength 14139 } 14140 if postIndex > l { 14141 return io.ErrUnexpectedEOF 14142 } 14143 if m.Target == nil { 14144 m.Target = &Target{} 14145 } 14146 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 14147 return err 14148 } 14149 iNdEx = postIndex 14150 case 4: 14151 if wireType != 2 { 14152 return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) 14153 } 14154 var msglen int 14155 for shift := uint(0); ; shift += 7 { 14156 if shift >= 64 { 14157 return ErrIntOverflow 14158 } 14159 if iNdEx >= l { 14160 return io.ErrUnexpectedEOF 14161 } 14162 b := dAtA[iNdEx] 14163 iNdEx++ 14164 msglen |= int(b&0x7F) << shift 14165 if b < 0x80 { 14166 break 14167 } 14168 } 14169 if msglen < 0 { 14170 return ErrInvalidLength 14171 } 14172 postIndex := iNdEx + msglen 14173 if postIndex < 0 { 14174 return ErrInvalidLength 14175 } 14176 if postIndex > l { 14177 return io.ErrUnexpectedEOF 14178 } 14179 if m.Query == nil { 14180 m.Query = &BoundQuery{} 14181 } 14182 if err := m.Query.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 14183 return err 14184 } 14185 iNdEx = postIndex 14186 case 5: 14187 if wireType != 2 { 14188 return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType) 14189 } 14190 var msglen int 14191 for shift := uint(0); ; shift += 7 { 14192 if shift >= 64 { 14193 return ErrIntOverflow 14194 } 14195 if iNdEx >= l { 14196 return io.ErrUnexpectedEOF 14197 } 14198 b := dAtA[iNdEx] 14199 iNdEx++ 14200 msglen |= int(b&0x7F) << shift 14201 if b < 0x80 { 14202 break 14203 } 14204 } 14205 if msglen < 0 { 14206 return ErrInvalidLength 14207 } 14208 postIndex := iNdEx + msglen 14209 if postIndex < 0 { 14210 return ErrInvalidLength 14211 } 14212 if postIndex > l { 14213 return io.ErrUnexpectedEOF 14214 } 14215 if m.Options == nil { 14216 m.Options = &ExecuteOptions{} 14217 } 14218 if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 14219 return err 14220 } 14221 iNdEx = postIndex 14222 case 6: 14223 if wireType != 2 { 14224 return fmt.Errorf("proto: wrong wireType = %d for field PreQueries", wireType) 14225 } 14226 var stringLen uint64 14227 for shift := uint(0); ; shift += 7 { 14228 if shift >= 64 { 14229 return ErrIntOverflow 14230 } 14231 if iNdEx >= l { 14232 return io.ErrUnexpectedEOF 14233 } 14234 b := dAtA[iNdEx] 14235 iNdEx++ 14236 stringLen |= uint64(b&0x7F) << shift 14237 if b < 0x80 { 14238 break 14239 } 14240 } 14241 intStringLen := int(stringLen) 14242 if intStringLen < 0 { 14243 return ErrInvalidLength 14244 } 14245 postIndex := iNdEx + intStringLen 14246 if postIndex < 0 { 14247 return ErrInvalidLength 14248 } 14249 if postIndex > l { 14250 return io.ErrUnexpectedEOF 14251 } 14252 m.PreQueries = append(m.PreQueries, string(dAtA[iNdEx:postIndex])) 14253 iNdEx = postIndex 14254 case 7: 14255 if wireType != 2 { 14256 return fmt.Errorf("proto: wrong wireType = %d for field PostBeginQueries", wireType) 14257 } 14258 var stringLen uint64 14259 for shift := uint(0); ; shift += 7 { 14260 if shift >= 64 { 14261 return ErrIntOverflow 14262 } 14263 if iNdEx >= l { 14264 return io.ErrUnexpectedEOF 14265 } 14266 b := dAtA[iNdEx] 14267 iNdEx++ 14268 stringLen |= uint64(b&0x7F) << shift 14269 if b < 0x80 { 14270 break 14271 } 14272 } 14273 intStringLen := int(stringLen) 14274 if intStringLen < 0 { 14275 return ErrInvalidLength 14276 } 14277 postIndex := iNdEx + intStringLen 14278 if postIndex < 0 { 14279 return ErrInvalidLength 14280 } 14281 if postIndex > l { 14282 return io.ErrUnexpectedEOF 14283 } 14284 m.PostBeginQueries = append(m.PostBeginQueries, string(dAtA[iNdEx:postIndex])) 14285 iNdEx = postIndex 14286 default: 14287 iNdEx = preIndex 14288 skippy, err := skip(dAtA[iNdEx:]) 14289 if err != nil { 14290 return err 14291 } 14292 if (skippy < 0) || (iNdEx+skippy) < 0 { 14293 return ErrInvalidLength 14294 } 14295 if (iNdEx + skippy) > l { 14296 return io.ErrUnexpectedEOF 14297 } 14298 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 14299 iNdEx += skippy 14300 } 14301 } 14302 14303 if iNdEx > l { 14304 return io.ErrUnexpectedEOF 14305 } 14306 return nil 14307 } 14308 func (m *ReserveBeginExecuteResponse) UnmarshalVT(dAtA []byte) error { 14309 l := len(dAtA) 14310 iNdEx := 0 14311 for iNdEx < l { 14312 preIndex := iNdEx 14313 var wire uint64 14314 for shift := uint(0); ; shift += 7 { 14315 if shift >= 64 { 14316 return ErrIntOverflow 14317 } 14318 if iNdEx >= l { 14319 return io.ErrUnexpectedEOF 14320 } 14321 b := dAtA[iNdEx] 14322 iNdEx++ 14323 wire |= uint64(b&0x7F) << shift 14324 if b < 0x80 { 14325 break 14326 } 14327 } 14328 fieldNum := int32(wire >> 3) 14329 wireType := int(wire & 0x7) 14330 if wireType == 4 { 14331 return fmt.Errorf("proto: ReserveBeginExecuteResponse: wiretype end group for non-group") 14332 } 14333 if fieldNum <= 0 { 14334 return fmt.Errorf("proto: ReserveBeginExecuteResponse: illegal tag %d (wire type %d)", fieldNum, wire) 14335 } 14336 switch fieldNum { 14337 case 1: 14338 if wireType != 2 { 14339 return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) 14340 } 14341 var msglen int 14342 for shift := uint(0); ; shift += 7 { 14343 if shift >= 64 { 14344 return ErrIntOverflow 14345 } 14346 if iNdEx >= l { 14347 return io.ErrUnexpectedEOF 14348 } 14349 b := dAtA[iNdEx] 14350 iNdEx++ 14351 msglen |= int(b&0x7F) << shift 14352 if b < 0x80 { 14353 break 14354 } 14355 } 14356 if msglen < 0 { 14357 return ErrInvalidLength 14358 } 14359 postIndex := iNdEx + msglen 14360 if postIndex < 0 { 14361 return ErrInvalidLength 14362 } 14363 if postIndex > l { 14364 return io.ErrUnexpectedEOF 14365 } 14366 if m.Error == nil { 14367 m.Error = &vtrpc.RPCError{} 14368 } 14369 if err := m.Error.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 14370 return err 14371 } 14372 iNdEx = postIndex 14373 case 2: 14374 if wireType != 2 { 14375 return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) 14376 } 14377 var msglen int 14378 for shift := uint(0); ; shift += 7 { 14379 if shift >= 64 { 14380 return ErrIntOverflow 14381 } 14382 if iNdEx >= l { 14383 return io.ErrUnexpectedEOF 14384 } 14385 b := dAtA[iNdEx] 14386 iNdEx++ 14387 msglen |= int(b&0x7F) << shift 14388 if b < 0x80 { 14389 break 14390 } 14391 } 14392 if msglen < 0 { 14393 return ErrInvalidLength 14394 } 14395 postIndex := iNdEx + msglen 14396 if postIndex < 0 { 14397 return ErrInvalidLength 14398 } 14399 if postIndex > l { 14400 return io.ErrUnexpectedEOF 14401 } 14402 if m.Result == nil { 14403 m.Result = &QueryResult{} 14404 } 14405 if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 14406 return err 14407 } 14408 iNdEx = postIndex 14409 case 3: 14410 if wireType != 0 { 14411 return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType) 14412 } 14413 m.TransactionId = 0 14414 for shift := uint(0); ; shift += 7 { 14415 if shift >= 64 { 14416 return ErrIntOverflow 14417 } 14418 if iNdEx >= l { 14419 return io.ErrUnexpectedEOF 14420 } 14421 b := dAtA[iNdEx] 14422 iNdEx++ 14423 m.TransactionId |= int64(b&0x7F) << shift 14424 if b < 0x80 { 14425 break 14426 } 14427 } 14428 case 4: 14429 if wireType != 0 { 14430 return fmt.Errorf("proto: wrong wireType = %d for field ReservedId", wireType) 14431 } 14432 m.ReservedId = 0 14433 for shift := uint(0); ; shift += 7 { 14434 if shift >= 64 { 14435 return ErrIntOverflow 14436 } 14437 if iNdEx >= l { 14438 return io.ErrUnexpectedEOF 14439 } 14440 b := dAtA[iNdEx] 14441 iNdEx++ 14442 m.ReservedId |= int64(b&0x7F) << shift 14443 if b < 0x80 { 14444 break 14445 } 14446 } 14447 case 5: 14448 if wireType != 2 { 14449 return fmt.Errorf("proto: wrong wireType = %d for field TabletAlias", wireType) 14450 } 14451 var msglen int 14452 for shift := uint(0); ; shift += 7 { 14453 if shift >= 64 { 14454 return ErrIntOverflow 14455 } 14456 if iNdEx >= l { 14457 return io.ErrUnexpectedEOF 14458 } 14459 b := dAtA[iNdEx] 14460 iNdEx++ 14461 msglen |= int(b&0x7F) << shift 14462 if b < 0x80 { 14463 break 14464 } 14465 } 14466 if msglen < 0 { 14467 return ErrInvalidLength 14468 } 14469 postIndex := iNdEx + msglen 14470 if postIndex < 0 { 14471 return ErrInvalidLength 14472 } 14473 if postIndex > l { 14474 return io.ErrUnexpectedEOF 14475 } 14476 if m.TabletAlias == nil { 14477 m.TabletAlias = &topodata.TabletAlias{} 14478 } 14479 if err := m.TabletAlias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 14480 return err 14481 } 14482 iNdEx = postIndex 14483 default: 14484 iNdEx = preIndex 14485 skippy, err := skip(dAtA[iNdEx:]) 14486 if err != nil { 14487 return err 14488 } 14489 if (skippy < 0) || (iNdEx+skippy) < 0 { 14490 return ErrInvalidLength 14491 } 14492 if (iNdEx + skippy) > l { 14493 return io.ErrUnexpectedEOF 14494 } 14495 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 14496 iNdEx += skippy 14497 } 14498 } 14499 14500 if iNdEx > l { 14501 return io.ErrUnexpectedEOF 14502 } 14503 return nil 14504 } 14505 func (m *ReserveBeginStreamExecuteRequest) UnmarshalVT(dAtA []byte) error { 14506 l := len(dAtA) 14507 iNdEx := 0 14508 for iNdEx < l { 14509 preIndex := iNdEx 14510 var wire uint64 14511 for shift := uint(0); ; shift += 7 { 14512 if shift >= 64 { 14513 return ErrIntOverflow 14514 } 14515 if iNdEx >= l { 14516 return io.ErrUnexpectedEOF 14517 } 14518 b := dAtA[iNdEx] 14519 iNdEx++ 14520 wire |= uint64(b&0x7F) << shift 14521 if b < 0x80 { 14522 break 14523 } 14524 } 14525 fieldNum := int32(wire >> 3) 14526 wireType := int(wire & 0x7) 14527 if wireType == 4 { 14528 return fmt.Errorf("proto: ReserveBeginStreamExecuteRequest: wiretype end group for non-group") 14529 } 14530 if fieldNum <= 0 { 14531 return fmt.Errorf("proto: ReserveBeginStreamExecuteRequest: illegal tag %d (wire type %d)", fieldNum, wire) 14532 } 14533 switch fieldNum { 14534 case 1: 14535 if wireType != 2 { 14536 return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType) 14537 } 14538 var msglen int 14539 for shift := uint(0); ; shift += 7 { 14540 if shift >= 64 { 14541 return ErrIntOverflow 14542 } 14543 if iNdEx >= l { 14544 return io.ErrUnexpectedEOF 14545 } 14546 b := dAtA[iNdEx] 14547 iNdEx++ 14548 msglen |= int(b&0x7F) << shift 14549 if b < 0x80 { 14550 break 14551 } 14552 } 14553 if msglen < 0 { 14554 return ErrInvalidLength 14555 } 14556 postIndex := iNdEx + msglen 14557 if postIndex < 0 { 14558 return ErrInvalidLength 14559 } 14560 if postIndex > l { 14561 return io.ErrUnexpectedEOF 14562 } 14563 if m.EffectiveCallerId == nil { 14564 m.EffectiveCallerId = &vtrpc.CallerID{} 14565 } 14566 if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 14567 return err 14568 } 14569 iNdEx = postIndex 14570 case 2: 14571 if wireType != 2 { 14572 return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType) 14573 } 14574 var msglen int 14575 for shift := uint(0); ; shift += 7 { 14576 if shift >= 64 { 14577 return ErrIntOverflow 14578 } 14579 if iNdEx >= l { 14580 return io.ErrUnexpectedEOF 14581 } 14582 b := dAtA[iNdEx] 14583 iNdEx++ 14584 msglen |= int(b&0x7F) << shift 14585 if b < 0x80 { 14586 break 14587 } 14588 } 14589 if msglen < 0 { 14590 return ErrInvalidLength 14591 } 14592 postIndex := iNdEx + msglen 14593 if postIndex < 0 { 14594 return ErrInvalidLength 14595 } 14596 if postIndex > l { 14597 return io.ErrUnexpectedEOF 14598 } 14599 if m.ImmediateCallerId == nil { 14600 m.ImmediateCallerId = &VTGateCallerID{} 14601 } 14602 if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 14603 return err 14604 } 14605 iNdEx = postIndex 14606 case 3: 14607 if wireType != 2 { 14608 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 14609 } 14610 var msglen int 14611 for shift := uint(0); ; shift += 7 { 14612 if shift >= 64 { 14613 return ErrIntOverflow 14614 } 14615 if iNdEx >= l { 14616 return io.ErrUnexpectedEOF 14617 } 14618 b := dAtA[iNdEx] 14619 iNdEx++ 14620 msglen |= int(b&0x7F) << shift 14621 if b < 0x80 { 14622 break 14623 } 14624 } 14625 if msglen < 0 { 14626 return ErrInvalidLength 14627 } 14628 postIndex := iNdEx + msglen 14629 if postIndex < 0 { 14630 return ErrInvalidLength 14631 } 14632 if postIndex > l { 14633 return io.ErrUnexpectedEOF 14634 } 14635 if m.Target == nil { 14636 m.Target = &Target{} 14637 } 14638 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 14639 return err 14640 } 14641 iNdEx = postIndex 14642 case 4: 14643 if wireType != 2 { 14644 return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) 14645 } 14646 var msglen int 14647 for shift := uint(0); ; shift += 7 { 14648 if shift >= 64 { 14649 return ErrIntOverflow 14650 } 14651 if iNdEx >= l { 14652 return io.ErrUnexpectedEOF 14653 } 14654 b := dAtA[iNdEx] 14655 iNdEx++ 14656 msglen |= int(b&0x7F) << shift 14657 if b < 0x80 { 14658 break 14659 } 14660 } 14661 if msglen < 0 { 14662 return ErrInvalidLength 14663 } 14664 postIndex := iNdEx + msglen 14665 if postIndex < 0 { 14666 return ErrInvalidLength 14667 } 14668 if postIndex > l { 14669 return io.ErrUnexpectedEOF 14670 } 14671 if m.Query == nil { 14672 m.Query = &BoundQuery{} 14673 } 14674 if err := m.Query.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 14675 return err 14676 } 14677 iNdEx = postIndex 14678 case 5: 14679 if wireType != 2 { 14680 return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType) 14681 } 14682 var msglen int 14683 for shift := uint(0); ; shift += 7 { 14684 if shift >= 64 { 14685 return ErrIntOverflow 14686 } 14687 if iNdEx >= l { 14688 return io.ErrUnexpectedEOF 14689 } 14690 b := dAtA[iNdEx] 14691 iNdEx++ 14692 msglen |= int(b&0x7F) << shift 14693 if b < 0x80 { 14694 break 14695 } 14696 } 14697 if msglen < 0 { 14698 return ErrInvalidLength 14699 } 14700 postIndex := iNdEx + msglen 14701 if postIndex < 0 { 14702 return ErrInvalidLength 14703 } 14704 if postIndex > l { 14705 return io.ErrUnexpectedEOF 14706 } 14707 if m.Options == nil { 14708 m.Options = &ExecuteOptions{} 14709 } 14710 if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 14711 return err 14712 } 14713 iNdEx = postIndex 14714 case 6: 14715 if wireType != 2 { 14716 return fmt.Errorf("proto: wrong wireType = %d for field PreQueries", wireType) 14717 } 14718 var stringLen uint64 14719 for shift := uint(0); ; shift += 7 { 14720 if shift >= 64 { 14721 return ErrIntOverflow 14722 } 14723 if iNdEx >= l { 14724 return io.ErrUnexpectedEOF 14725 } 14726 b := dAtA[iNdEx] 14727 iNdEx++ 14728 stringLen |= uint64(b&0x7F) << shift 14729 if b < 0x80 { 14730 break 14731 } 14732 } 14733 intStringLen := int(stringLen) 14734 if intStringLen < 0 { 14735 return ErrInvalidLength 14736 } 14737 postIndex := iNdEx + intStringLen 14738 if postIndex < 0 { 14739 return ErrInvalidLength 14740 } 14741 if postIndex > l { 14742 return io.ErrUnexpectedEOF 14743 } 14744 m.PreQueries = append(m.PreQueries, string(dAtA[iNdEx:postIndex])) 14745 iNdEx = postIndex 14746 case 7: 14747 if wireType != 2 { 14748 return fmt.Errorf("proto: wrong wireType = %d for field PostBeginQueries", wireType) 14749 } 14750 var stringLen uint64 14751 for shift := uint(0); ; shift += 7 { 14752 if shift >= 64 { 14753 return ErrIntOverflow 14754 } 14755 if iNdEx >= l { 14756 return io.ErrUnexpectedEOF 14757 } 14758 b := dAtA[iNdEx] 14759 iNdEx++ 14760 stringLen |= uint64(b&0x7F) << shift 14761 if b < 0x80 { 14762 break 14763 } 14764 } 14765 intStringLen := int(stringLen) 14766 if intStringLen < 0 { 14767 return ErrInvalidLength 14768 } 14769 postIndex := iNdEx + intStringLen 14770 if postIndex < 0 { 14771 return ErrInvalidLength 14772 } 14773 if postIndex > l { 14774 return io.ErrUnexpectedEOF 14775 } 14776 m.PostBeginQueries = append(m.PostBeginQueries, string(dAtA[iNdEx:postIndex])) 14777 iNdEx = postIndex 14778 default: 14779 iNdEx = preIndex 14780 skippy, err := skip(dAtA[iNdEx:]) 14781 if err != nil { 14782 return err 14783 } 14784 if (skippy < 0) || (iNdEx+skippy) < 0 { 14785 return ErrInvalidLength 14786 } 14787 if (iNdEx + skippy) > l { 14788 return io.ErrUnexpectedEOF 14789 } 14790 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 14791 iNdEx += skippy 14792 } 14793 } 14794 14795 if iNdEx > l { 14796 return io.ErrUnexpectedEOF 14797 } 14798 return nil 14799 } 14800 func (m *ReserveBeginStreamExecuteResponse) UnmarshalVT(dAtA []byte) error { 14801 l := len(dAtA) 14802 iNdEx := 0 14803 for iNdEx < l { 14804 preIndex := iNdEx 14805 var wire uint64 14806 for shift := uint(0); ; shift += 7 { 14807 if shift >= 64 { 14808 return ErrIntOverflow 14809 } 14810 if iNdEx >= l { 14811 return io.ErrUnexpectedEOF 14812 } 14813 b := dAtA[iNdEx] 14814 iNdEx++ 14815 wire |= uint64(b&0x7F) << shift 14816 if b < 0x80 { 14817 break 14818 } 14819 } 14820 fieldNum := int32(wire >> 3) 14821 wireType := int(wire & 0x7) 14822 if wireType == 4 { 14823 return fmt.Errorf("proto: ReserveBeginStreamExecuteResponse: wiretype end group for non-group") 14824 } 14825 if fieldNum <= 0 { 14826 return fmt.Errorf("proto: ReserveBeginStreamExecuteResponse: illegal tag %d (wire type %d)", fieldNum, wire) 14827 } 14828 switch fieldNum { 14829 case 1: 14830 if wireType != 2 { 14831 return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) 14832 } 14833 var msglen int 14834 for shift := uint(0); ; shift += 7 { 14835 if shift >= 64 { 14836 return ErrIntOverflow 14837 } 14838 if iNdEx >= l { 14839 return io.ErrUnexpectedEOF 14840 } 14841 b := dAtA[iNdEx] 14842 iNdEx++ 14843 msglen |= int(b&0x7F) << shift 14844 if b < 0x80 { 14845 break 14846 } 14847 } 14848 if msglen < 0 { 14849 return ErrInvalidLength 14850 } 14851 postIndex := iNdEx + msglen 14852 if postIndex < 0 { 14853 return ErrInvalidLength 14854 } 14855 if postIndex > l { 14856 return io.ErrUnexpectedEOF 14857 } 14858 if m.Error == nil { 14859 m.Error = &vtrpc.RPCError{} 14860 } 14861 if err := m.Error.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 14862 return err 14863 } 14864 iNdEx = postIndex 14865 case 2: 14866 if wireType != 2 { 14867 return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) 14868 } 14869 var msglen int 14870 for shift := uint(0); ; shift += 7 { 14871 if shift >= 64 { 14872 return ErrIntOverflow 14873 } 14874 if iNdEx >= l { 14875 return io.ErrUnexpectedEOF 14876 } 14877 b := dAtA[iNdEx] 14878 iNdEx++ 14879 msglen |= int(b&0x7F) << shift 14880 if b < 0x80 { 14881 break 14882 } 14883 } 14884 if msglen < 0 { 14885 return ErrInvalidLength 14886 } 14887 postIndex := iNdEx + msglen 14888 if postIndex < 0 { 14889 return ErrInvalidLength 14890 } 14891 if postIndex > l { 14892 return io.ErrUnexpectedEOF 14893 } 14894 if m.Result == nil { 14895 m.Result = &QueryResult{} 14896 } 14897 if err := m.Result.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 14898 return err 14899 } 14900 iNdEx = postIndex 14901 case 3: 14902 if wireType != 0 { 14903 return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType) 14904 } 14905 m.TransactionId = 0 14906 for shift := uint(0); ; shift += 7 { 14907 if shift >= 64 { 14908 return ErrIntOverflow 14909 } 14910 if iNdEx >= l { 14911 return io.ErrUnexpectedEOF 14912 } 14913 b := dAtA[iNdEx] 14914 iNdEx++ 14915 m.TransactionId |= int64(b&0x7F) << shift 14916 if b < 0x80 { 14917 break 14918 } 14919 } 14920 case 4: 14921 if wireType != 0 { 14922 return fmt.Errorf("proto: wrong wireType = %d for field ReservedId", wireType) 14923 } 14924 m.ReservedId = 0 14925 for shift := uint(0); ; shift += 7 { 14926 if shift >= 64 { 14927 return ErrIntOverflow 14928 } 14929 if iNdEx >= l { 14930 return io.ErrUnexpectedEOF 14931 } 14932 b := dAtA[iNdEx] 14933 iNdEx++ 14934 m.ReservedId |= int64(b&0x7F) << shift 14935 if b < 0x80 { 14936 break 14937 } 14938 } 14939 case 5: 14940 if wireType != 2 { 14941 return fmt.Errorf("proto: wrong wireType = %d for field TabletAlias", wireType) 14942 } 14943 var msglen int 14944 for shift := uint(0); ; shift += 7 { 14945 if shift >= 64 { 14946 return ErrIntOverflow 14947 } 14948 if iNdEx >= l { 14949 return io.ErrUnexpectedEOF 14950 } 14951 b := dAtA[iNdEx] 14952 iNdEx++ 14953 msglen |= int(b&0x7F) << shift 14954 if b < 0x80 { 14955 break 14956 } 14957 } 14958 if msglen < 0 { 14959 return ErrInvalidLength 14960 } 14961 postIndex := iNdEx + msglen 14962 if postIndex < 0 { 14963 return ErrInvalidLength 14964 } 14965 if postIndex > l { 14966 return io.ErrUnexpectedEOF 14967 } 14968 if m.TabletAlias == nil { 14969 m.TabletAlias = &topodata.TabletAlias{} 14970 } 14971 if err := m.TabletAlias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 14972 return err 14973 } 14974 iNdEx = postIndex 14975 default: 14976 iNdEx = preIndex 14977 skippy, err := skip(dAtA[iNdEx:]) 14978 if err != nil { 14979 return err 14980 } 14981 if (skippy < 0) || (iNdEx+skippy) < 0 { 14982 return ErrInvalidLength 14983 } 14984 if (iNdEx + skippy) > l { 14985 return io.ErrUnexpectedEOF 14986 } 14987 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 14988 iNdEx += skippy 14989 } 14990 } 14991 14992 if iNdEx > l { 14993 return io.ErrUnexpectedEOF 14994 } 14995 return nil 14996 } 14997 func (m *ReleaseRequest) UnmarshalVT(dAtA []byte) error { 14998 l := len(dAtA) 14999 iNdEx := 0 15000 for iNdEx < l { 15001 preIndex := iNdEx 15002 var wire uint64 15003 for shift := uint(0); ; shift += 7 { 15004 if shift >= 64 { 15005 return ErrIntOverflow 15006 } 15007 if iNdEx >= l { 15008 return io.ErrUnexpectedEOF 15009 } 15010 b := dAtA[iNdEx] 15011 iNdEx++ 15012 wire |= uint64(b&0x7F) << shift 15013 if b < 0x80 { 15014 break 15015 } 15016 } 15017 fieldNum := int32(wire >> 3) 15018 wireType := int(wire & 0x7) 15019 if wireType == 4 { 15020 return fmt.Errorf("proto: ReleaseRequest: wiretype end group for non-group") 15021 } 15022 if fieldNum <= 0 { 15023 return fmt.Errorf("proto: ReleaseRequest: illegal tag %d (wire type %d)", fieldNum, wire) 15024 } 15025 switch fieldNum { 15026 case 1: 15027 if wireType != 2 { 15028 return fmt.Errorf("proto: wrong wireType = %d for field EffectiveCallerId", wireType) 15029 } 15030 var msglen int 15031 for shift := uint(0); ; shift += 7 { 15032 if shift >= 64 { 15033 return ErrIntOverflow 15034 } 15035 if iNdEx >= l { 15036 return io.ErrUnexpectedEOF 15037 } 15038 b := dAtA[iNdEx] 15039 iNdEx++ 15040 msglen |= int(b&0x7F) << shift 15041 if b < 0x80 { 15042 break 15043 } 15044 } 15045 if msglen < 0 { 15046 return ErrInvalidLength 15047 } 15048 postIndex := iNdEx + msglen 15049 if postIndex < 0 { 15050 return ErrInvalidLength 15051 } 15052 if postIndex > l { 15053 return io.ErrUnexpectedEOF 15054 } 15055 if m.EffectiveCallerId == nil { 15056 m.EffectiveCallerId = &vtrpc.CallerID{} 15057 } 15058 if err := m.EffectiveCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 15059 return err 15060 } 15061 iNdEx = postIndex 15062 case 2: 15063 if wireType != 2 { 15064 return fmt.Errorf("proto: wrong wireType = %d for field ImmediateCallerId", wireType) 15065 } 15066 var msglen int 15067 for shift := uint(0); ; shift += 7 { 15068 if shift >= 64 { 15069 return ErrIntOverflow 15070 } 15071 if iNdEx >= l { 15072 return io.ErrUnexpectedEOF 15073 } 15074 b := dAtA[iNdEx] 15075 iNdEx++ 15076 msglen |= int(b&0x7F) << shift 15077 if b < 0x80 { 15078 break 15079 } 15080 } 15081 if msglen < 0 { 15082 return ErrInvalidLength 15083 } 15084 postIndex := iNdEx + msglen 15085 if postIndex < 0 { 15086 return ErrInvalidLength 15087 } 15088 if postIndex > l { 15089 return io.ErrUnexpectedEOF 15090 } 15091 if m.ImmediateCallerId == nil { 15092 m.ImmediateCallerId = &VTGateCallerID{} 15093 } 15094 if err := m.ImmediateCallerId.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 15095 return err 15096 } 15097 iNdEx = postIndex 15098 case 3: 15099 if wireType != 2 { 15100 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 15101 } 15102 var msglen int 15103 for shift := uint(0); ; shift += 7 { 15104 if shift >= 64 { 15105 return ErrIntOverflow 15106 } 15107 if iNdEx >= l { 15108 return io.ErrUnexpectedEOF 15109 } 15110 b := dAtA[iNdEx] 15111 iNdEx++ 15112 msglen |= int(b&0x7F) << shift 15113 if b < 0x80 { 15114 break 15115 } 15116 } 15117 if msglen < 0 { 15118 return ErrInvalidLength 15119 } 15120 postIndex := iNdEx + msglen 15121 if postIndex < 0 { 15122 return ErrInvalidLength 15123 } 15124 if postIndex > l { 15125 return io.ErrUnexpectedEOF 15126 } 15127 if m.Target == nil { 15128 m.Target = &Target{} 15129 } 15130 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 15131 return err 15132 } 15133 iNdEx = postIndex 15134 case 4: 15135 if wireType != 0 { 15136 return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType) 15137 } 15138 m.TransactionId = 0 15139 for shift := uint(0); ; shift += 7 { 15140 if shift >= 64 { 15141 return ErrIntOverflow 15142 } 15143 if iNdEx >= l { 15144 return io.ErrUnexpectedEOF 15145 } 15146 b := dAtA[iNdEx] 15147 iNdEx++ 15148 m.TransactionId |= int64(b&0x7F) << shift 15149 if b < 0x80 { 15150 break 15151 } 15152 } 15153 case 5: 15154 if wireType != 0 { 15155 return fmt.Errorf("proto: wrong wireType = %d for field ReservedId", wireType) 15156 } 15157 m.ReservedId = 0 15158 for shift := uint(0); ; shift += 7 { 15159 if shift >= 64 { 15160 return ErrIntOverflow 15161 } 15162 if iNdEx >= l { 15163 return io.ErrUnexpectedEOF 15164 } 15165 b := dAtA[iNdEx] 15166 iNdEx++ 15167 m.ReservedId |= int64(b&0x7F) << shift 15168 if b < 0x80 { 15169 break 15170 } 15171 } 15172 default: 15173 iNdEx = preIndex 15174 skippy, err := skip(dAtA[iNdEx:]) 15175 if err != nil { 15176 return err 15177 } 15178 if (skippy < 0) || (iNdEx+skippy) < 0 { 15179 return ErrInvalidLength 15180 } 15181 if (iNdEx + skippy) > l { 15182 return io.ErrUnexpectedEOF 15183 } 15184 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 15185 iNdEx += skippy 15186 } 15187 } 15188 15189 if iNdEx > l { 15190 return io.ErrUnexpectedEOF 15191 } 15192 return nil 15193 } 15194 func (m *ReleaseResponse) UnmarshalVT(dAtA []byte) error { 15195 l := len(dAtA) 15196 iNdEx := 0 15197 for iNdEx < l { 15198 preIndex := iNdEx 15199 var wire uint64 15200 for shift := uint(0); ; shift += 7 { 15201 if shift >= 64 { 15202 return ErrIntOverflow 15203 } 15204 if iNdEx >= l { 15205 return io.ErrUnexpectedEOF 15206 } 15207 b := dAtA[iNdEx] 15208 iNdEx++ 15209 wire |= uint64(b&0x7F) << shift 15210 if b < 0x80 { 15211 break 15212 } 15213 } 15214 fieldNum := int32(wire >> 3) 15215 wireType := int(wire & 0x7) 15216 if wireType == 4 { 15217 return fmt.Errorf("proto: ReleaseResponse: wiretype end group for non-group") 15218 } 15219 if fieldNum <= 0 { 15220 return fmt.Errorf("proto: ReleaseResponse: illegal tag %d (wire type %d)", fieldNum, wire) 15221 } 15222 switch fieldNum { 15223 default: 15224 iNdEx = preIndex 15225 skippy, err := skip(dAtA[iNdEx:]) 15226 if err != nil { 15227 return err 15228 } 15229 if (skippy < 0) || (iNdEx+skippy) < 0 { 15230 return ErrInvalidLength 15231 } 15232 if (iNdEx + skippy) > l { 15233 return io.ErrUnexpectedEOF 15234 } 15235 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 15236 iNdEx += skippy 15237 } 15238 } 15239 15240 if iNdEx > l { 15241 return io.ErrUnexpectedEOF 15242 } 15243 return nil 15244 } 15245 func (m *StreamHealthRequest) UnmarshalVT(dAtA []byte) error { 15246 l := len(dAtA) 15247 iNdEx := 0 15248 for iNdEx < l { 15249 preIndex := iNdEx 15250 var wire uint64 15251 for shift := uint(0); ; shift += 7 { 15252 if shift >= 64 { 15253 return ErrIntOverflow 15254 } 15255 if iNdEx >= l { 15256 return io.ErrUnexpectedEOF 15257 } 15258 b := dAtA[iNdEx] 15259 iNdEx++ 15260 wire |= uint64(b&0x7F) << shift 15261 if b < 0x80 { 15262 break 15263 } 15264 } 15265 fieldNum := int32(wire >> 3) 15266 wireType := int(wire & 0x7) 15267 if wireType == 4 { 15268 return fmt.Errorf("proto: StreamHealthRequest: wiretype end group for non-group") 15269 } 15270 if fieldNum <= 0 { 15271 return fmt.Errorf("proto: StreamHealthRequest: illegal tag %d (wire type %d)", fieldNum, wire) 15272 } 15273 switch fieldNum { 15274 default: 15275 iNdEx = preIndex 15276 skippy, err := skip(dAtA[iNdEx:]) 15277 if err != nil { 15278 return err 15279 } 15280 if (skippy < 0) || (iNdEx+skippy) < 0 { 15281 return ErrInvalidLength 15282 } 15283 if (iNdEx + skippy) > l { 15284 return io.ErrUnexpectedEOF 15285 } 15286 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 15287 iNdEx += skippy 15288 } 15289 } 15290 15291 if iNdEx > l { 15292 return io.ErrUnexpectedEOF 15293 } 15294 return nil 15295 } 15296 func (m *RealtimeStats) UnmarshalVT(dAtA []byte) error { 15297 l := len(dAtA) 15298 iNdEx := 0 15299 for iNdEx < l { 15300 preIndex := iNdEx 15301 var wire uint64 15302 for shift := uint(0); ; shift += 7 { 15303 if shift >= 64 { 15304 return ErrIntOverflow 15305 } 15306 if iNdEx >= l { 15307 return io.ErrUnexpectedEOF 15308 } 15309 b := dAtA[iNdEx] 15310 iNdEx++ 15311 wire |= uint64(b&0x7F) << shift 15312 if b < 0x80 { 15313 break 15314 } 15315 } 15316 fieldNum := int32(wire >> 3) 15317 wireType := int(wire & 0x7) 15318 if wireType == 4 { 15319 return fmt.Errorf("proto: RealtimeStats: wiretype end group for non-group") 15320 } 15321 if fieldNum <= 0 { 15322 return fmt.Errorf("proto: RealtimeStats: illegal tag %d (wire type %d)", fieldNum, wire) 15323 } 15324 switch fieldNum { 15325 case 1: 15326 if wireType != 2 { 15327 return fmt.Errorf("proto: wrong wireType = %d for field HealthError", wireType) 15328 } 15329 var stringLen uint64 15330 for shift := uint(0); ; shift += 7 { 15331 if shift >= 64 { 15332 return ErrIntOverflow 15333 } 15334 if iNdEx >= l { 15335 return io.ErrUnexpectedEOF 15336 } 15337 b := dAtA[iNdEx] 15338 iNdEx++ 15339 stringLen |= uint64(b&0x7F) << shift 15340 if b < 0x80 { 15341 break 15342 } 15343 } 15344 intStringLen := int(stringLen) 15345 if intStringLen < 0 { 15346 return ErrInvalidLength 15347 } 15348 postIndex := iNdEx + intStringLen 15349 if postIndex < 0 { 15350 return ErrInvalidLength 15351 } 15352 if postIndex > l { 15353 return io.ErrUnexpectedEOF 15354 } 15355 m.HealthError = string(dAtA[iNdEx:postIndex]) 15356 iNdEx = postIndex 15357 case 2: 15358 if wireType != 0 { 15359 return fmt.Errorf("proto: wrong wireType = %d for field ReplicationLagSeconds", wireType) 15360 } 15361 m.ReplicationLagSeconds = 0 15362 for shift := uint(0); ; shift += 7 { 15363 if shift >= 64 { 15364 return ErrIntOverflow 15365 } 15366 if iNdEx >= l { 15367 return io.ErrUnexpectedEOF 15368 } 15369 b := dAtA[iNdEx] 15370 iNdEx++ 15371 m.ReplicationLagSeconds |= uint32(b&0x7F) << shift 15372 if b < 0x80 { 15373 break 15374 } 15375 } 15376 case 3: 15377 if wireType != 0 { 15378 return fmt.Errorf("proto: wrong wireType = %d for field BinlogPlayersCount", wireType) 15379 } 15380 m.BinlogPlayersCount = 0 15381 for shift := uint(0); ; shift += 7 { 15382 if shift >= 64 { 15383 return ErrIntOverflow 15384 } 15385 if iNdEx >= l { 15386 return io.ErrUnexpectedEOF 15387 } 15388 b := dAtA[iNdEx] 15389 iNdEx++ 15390 m.BinlogPlayersCount |= int32(b&0x7F) << shift 15391 if b < 0x80 { 15392 break 15393 } 15394 } 15395 case 4: 15396 if wireType != 0 { 15397 return fmt.Errorf("proto: wrong wireType = %d for field FilteredReplicationLagSeconds", wireType) 15398 } 15399 m.FilteredReplicationLagSeconds = 0 15400 for shift := uint(0); ; shift += 7 { 15401 if shift >= 64 { 15402 return ErrIntOverflow 15403 } 15404 if iNdEx >= l { 15405 return io.ErrUnexpectedEOF 15406 } 15407 b := dAtA[iNdEx] 15408 iNdEx++ 15409 m.FilteredReplicationLagSeconds |= int64(b&0x7F) << shift 15410 if b < 0x80 { 15411 break 15412 } 15413 } 15414 case 5: 15415 if wireType != 1 { 15416 return fmt.Errorf("proto: wrong wireType = %d for field CpuUsage", wireType) 15417 } 15418 var v uint64 15419 if (iNdEx + 8) > l { 15420 return io.ErrUnexpectedEOF 15421 } 15422 v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:])) 15423 iNdEx += 8 15424 m.CpuUsage = float64(math.Float64frombits(v)) 15425 case 6: 15426 if wireType != 1 { 15427 return fmt.Errorf("proto: wrong wireType = %d for field Qps", wireType) 15428 } 15429 var v uint64 15430 if (iNdEx + 8) > l { 15431 return io.ErrUnexpectedEOF 15432 } 15433 v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:])) 15434 iNdEx += 8 15435 m.Qps = float64(math.Float64frombits(v)) 15436 case 7: 15437 if wireType != 2 { 15438 return fmt.Errorf("proto: wrong wireType = %d for field TableSchemaChanged", wireType) 15439 } 15440 var stringLen uint64 15441 for shift := uint(0); ; shift += 7 { 15442 if shift >= 64 { 15443 return ErrIntOverflow 15444 } 15445 if iNdEx >= l { 15446 return io.ErrUnexpectedEOF 15447 } 15448 b := dAtA[iNdEx] 15449 iNdEx++ 15450 stringLen |= uint64(b&0x7F) << shift 15451 if b < 0x80 { 15452 break 15453 } 15454 } 15455 intStringLen := int(stringLen) 15456 if intStringLen < 0 { 15457 return ErrInvalidLength 15458 } 15459 postIndex := iNdEx + intStringLen 15460 if postIndex < 0 { 15461 return ErrInvalidLength 15462 } 15463 if postIndex > l { 15464 return io.ErrUnexpectedEOF 15465 } 15466 m.TableSchemaChanged = append(m.TableSchemaChanged, string(dAtA[iNdEx:postIndex])) 15467 iNdEx = postIndex 15468 default: 15469 iNdEx = preIndex 15470 skippy, err := skip(dAtA[iNdEx:]) 15471 if err != nil { 15472 return err 15473 } 15474 if (skippy < 0) || (iNdEx+skippy) < 0 { 15475 return ErrInvalidLength 15476 } 15477 if (iNdEx + skippy) > l { 15478 return io.ErrUnexpectedEOF 15479 } 15480 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 15481 iNdEx += skippy 15482 } 15483 } 15484 15485 if iNdEx > l { 15486 return io.ErrUnexpectedEOF 15487 } 15488 return nil 15489 } 15490 func (m *AggregateStats) UnmarshalVT(dAtA []byte) error { 15491 l := len(dAtA) 15492 iNdEx := 0 15493 for iNdEx < l { 15494 preIndex := iNdEx 15495 var wire uint64 15496 for shift := uint(0); ; shift += 7 { 15497 if shift >= 64 { 15498 return ErrIntOverflow 15499 } 15500 if iNdEx >= l { 15501 return io.ErrUnexpectedEOF 15502 } 15503 b := dAtA[iNdEx] 15504 iNdEx++ 15505 wire |= uint64(b&0x7F) << shift 15506 if b < 0x80 { 15507 break 15508 } 15509 } 15510 fieldNum := int32(wire >> 3) 15511 wireType := int(wire & 0x7) 15512 if wireType == 4 { 15513 return fmt.Errorf("proto: AggregateStats: wiretype end group for non-group") 15514 } 15515 if fieldNum <= 0 { 15516 return fmt.Errorf("proto: AggregateStats: illegal tag %d (wire type %d)", fieldNum, wire) 15517 } 15518 switch fieldNum { 15519 case 1: 15520 if wireType != 0 { 15521 return fmt.Errorf("proto: wrong wireType = %d for field HealthyTabletCount", wireType) 15522 } 15523 m.HealthyTabletCount = 0 15524 for shift := uint(0); ; shift += 7 { 15525 if shift >= 64 { 15526 return ErrIntOverflow 15527 } 15528 if iNdEx >= l { 15529 return io.ErrUnexpectedEOF 15530 } 15531 b := dAtA[iNdEx] 15532 iNdEx++ 15533 m.HealthyTabletCount |= int32(b&0x7F) << shift 15534 if b < 0x80 { 15535 break 15536 } 15537 } 15538 case 2: 15539 if wireType != 0 { 15540 return fmt.Errorf("proto: wrong wireType = %d for field UnhealthyTabletCount", wireType) 15541 } 15542 m.UnhealthyTabletCount = 0 15543 for shift := uint(0); ; shift += 7 { 15544 if shift >= 64 { 15545 return ErrIntOverflow 15546 } 15547 if iNdEx >= l { 15548 return io.ErrUnexpectedEOF 15549 } 15550 b := dAtA[iNdEx] 15551 iNdEx++ 15552 m.UnhealthyTabletCount |= int32(b&0x7F) << shift 15553 if b < 0x80 { 15554 break 15555 } 15556 } 15557 case 3: 15558 if wireType != 0 { 15559 return fmt.Errorf("proto: wrong wireType = %d for field ReplicationLagSecondsMin", wireType) 15560 } 15561 m.ReplicationLagSecondsMin = 0 15562 for shift := uint(0); ; shift += 7 { 15563 if shift >= 64 { 15564 return ErrIntOverflow 15565 } 15566 if iNdEx >= l { 15567 return io.ErrUnexpectedEOF 15568 } 15569 b := dAtA[iNdEx] 15570 iNdEx++ 15571 m.ReplicationLagSecondsMin |= uint32(b&0x7F) << shift 15572 if b < 0x80 { 15573 break 15574 } 15575 } 15576 case 4: 15577 if wireType != 0 { 15578 return fmt.Errorf("proto: wrong wireType = %d for field ReplicationLagSecondsMax", wireType) 15579 } 15580 m.ReplicationLagSecondsMax = 0 15581 for shift := uint(0); ; shift += 7 { 15582 if shift >= 64 { 15583 return ErrIntOverflow 15584 } 15585 if iNdEx >= l { 15586 return io.ErrUnexpectedEOF 15587 } 15588 b := dAtA[iNdEx] 15589 iNdEx++ 15590 m.ReplicationLagSecondsMax |= uint32(b&0x7F) << shift 15591 if b < 0x80 { 15592 break 15593 } 15594 } 15595 default: 15596 iNdEx = preIndex 15597 skippy, err := skip(dAtA[iNdEx:]) 15598 if err != nil { 15599 return err 15600 } 15601 if (skippy < 0) || (iNdEx+skippy) < 0 { 15602 return ErrInvalidLength 15603 } 15604 if (iNdEx + skippy) > l { 15605 return io.ErrUnexpectedEOF 15606 } 15607 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 15608 iNdEx += skippy 15609 } 15610 } 15611 15612 if iNdEx > l { 15613 return io.ErrUnexpectedEOF 15614 } 15615 return nil 15616 } 15617 func (m *StreamHealthResponse) UnmarshalVT(dAtA []byte) error { 15618 l := len(dAtA) 15619 iNdEx := 0 15620 for iNdEx < l { 15621 preIndex := iNdEx 15622 var wire uint64 15623 for shift := uint(0); ; shift += 7 { 15624 if shift >= 64 { 15625 return ErrIntOverflow 15626 } 15627 if iNdEx >= l { 15628 return io.ErrUnexpectedEOF 15629 } 15630 b := dAtA[iNdEx] 15631 iNdEx++ 15632 wire |= uint64(b&0x7F) << shift 15633 if b < 0x80 { 15634 break 15635 } 15636 } 15637 fieldNum := int32(wire >> 3) 15638 wireType := int(wire & 0x7) 15639 if wireType == 4 { 15640 return fmt.Errorf("proto: StreamHealthResponse: wiretype end group for non-group") 15641 } 15642 if fieldNum <= 0 { 15643 return fmt.Errorf("proto: StreamHealthResponse: illegal tag %d (wire type %d)", fieldNum, wire) 15644 } 15645 switch fieldNum { 15646 case 1: 15647 if wireType != 2 { 15648 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) 15649 } 15650 var msglen int 15651 for shift := uint(0); ; shift += 7 { 15652 if shift >= 64 { 15653 return ErrIntOverflow 15654 } 15655 if iNdEx >= l { 15656 return io.ErrUnexpectedEOF 15657 } 15658 b := dAtA[iNdEx] 15659 iNdEx++ 15660 msglen |= int(b&0x7F) << shift 15661 if b < 0x80 { 15662 break 15663 } 15664 } 15665 if msglen < 0 { 15666 return ErrInvalidLength 15667 } 15668 postIndex := iNdEx + msglen 15669 if postIndex < 0 { 15670 return ErrInvalidLength 15671 } 15672 if postIndex > l { 15673 return io.ErrUnexpectedEOF 15674 } 15675 if m.Target == nil { 15676 m.Target = &Target{} 15677 } 15678 if err := m.Target.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 15679 return err 15680 } 15681 iNdEx = postIndex 15682 case 2: 15683 if wireType != 0 { 15684 return fmt.Errorf("proto: wrong wireType = %d for field Serving", wireType) 15685 } 15686 var v int 15687 for shift := uint(0); ; shift += 7 { 15688 if shift >= 64 { 15689 return ErrIntOverflow 15690 } 15691 if iNdEx >= l { 15692 return io.ErrUnexpectedEOF 15693 } 15694 b := dAtA[iNdEx] 15695 iNdEx++ 15696 v |= int(b&0x7F) << shift 15697 if b < 0x80 { 15698 break 15699 } 15700 } 15701 m.Serving = bool(v != 0) 15702 case 3: 15703 if wireType != 0 { 15704 return fmt.Errorf("proto: wrong wireType = %d for field TabletExternallyReparentedTimestamp", wireType) 15705 } 15706 m.TabletExternallyReparentedTimestamp = 0 15707 for shift := uint(0); ; shift += 7 { 15708 if shift >= 64 { 15709 return ErrIntOverflow 15710 } 15711 if iNdEx >= l { 15712 return io.ErrUnexpectedEOF 15713 } 15714 b := dAtA[iNdEx] 15715 iNdEx++ 15716 m.TabletExternallyReparentedTimestamp |= int64(b&0x7F) << shift 15717 if b < 0x80 { 15718 break 15719 } 15720 } 15721 case 4: 15722 if wireType != 2 { 15723 return fmt.Errorf("proto: wrong wireType = %d for field RealtimeStats", wireType) 15724 } 15725 var msglen int 15726 for shift := uint(0); ; shift += 7 { 15727 if shift >= 64 { 15728 return ErrIntOverflow 15729 } 15730 if iNdEx >= l { 15731 return io.ErrUnexpectedEOF 15732 } 15733 b := dAtA[iNdEx] 15734 iNdEx++ 15735 msglen |= int(b&0x7F) << shift 15736 if b < 0x80 { 15737 break 15738 } 15739 } 15740 if msglen < 0 { 15741 return ErrInvalidLength 15742 } 15743 postIndex := iNdEx + msglen 15744 if postIndex < 0 { 15745 return ErrInvalidLength 15746 } 15747 if postIndex > l { 15748 return io.ErrUnexpectedEOF 15749 } 15750 if m.RealtimeStats == nil { 15751 m.RealtimeStats = &RealtimeStats{} 15752 } 15753 if err := m.RealtimeStats.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 15754 return err 15755 } 15756 iNdEx = postIndex 15757 case 5: 15758 if wireType != 2 { 15759 return fmt.Errorf("proto: wrong wireType = %d for field TabletAlias", wireType) 15760 } 15761 var msglen int 15762 for shift := uint(0); ; shift += 7 { 15763 if shift >= 64 { 15764 return ErrIntOverflow 15765 } 15766 if iNdEx >= l { 15767 return io.ErrUnexpectedEOF 15768 } 15769 b := dAtA[iNdEx] 15770 iNdEx++ 15771 msglen |= int(b&0x7F) << shift 15772 if b < 0x80 { 15773 break 15774 } 15775 } 15776 if msglen < 0 { 15777 return ErrInvalidLength 15778 } 15779 postIndex := iNdEx + msglen 15780 if postIndex < 0 { 15781 return ErrInvalidLength 15782 } 15783 if postIndex > l { 15784 return io.ErrUnexpectedEOF 15785 } 15786 if m.TabletAlias == nil { 15787 m.TabletAlias = &topodata.TabletAlias{} 15788 } 15789 if err := m.TabletAlias.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 15790 return err 15791 } 15792 iNdEx = postIndex 15793 default: 15794 iNdEx = preIndex 15795 skippy, err := skip(dAtA[iNdEx:]) 15796 if err != nil { 15797 return err 15798 } 15799 if (skippy < 0) || (iNdEx+skippy) < 0 { 15800 return ErrInvalidLength 15801 } 15802 if (iNdEx + skippy) > l { 15803 return io.ErrUnexpectedEOF 15804 } 15805 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 15806 iNdEx += skippy 15807 } 15808 } 15809 15810 if iNdEx > l { 15811 return io.ErrUnexpectedEOF 15812 } 15813 return nil 15814 } 15815 func (m *TransactionMetadata) UnmarshalVT(dAtA []byte) error { 15816 l := len(dAtA) 15817 iNdEx := 0 15818 for iNdEx < l { 15819 preIndex := iNdEx 15820 var wire uint64 15821 for shift := uint(0); ; shift += 7 { 15822 if shift >= 64 { 15823 return ErrIntOverflow 15824 } 15825 if iNdEx >= l { 15826 return io.ErrUnexpectedEOF 15827 } 15828 b := dAtA[iNdEx] 15829 iNdEx++ 15830 wire |= uint64(b&0x7F) << shift 15831 if b < 0x80 { 15832 break 15833 } 15834 } 15835 fieldNum := int32(wire >> 3) 15836 wireType := int(wire & 0x7) 15837 if wireType == 4 { 15838 return fmt.Errorf("proto: TransactionMetadata: wiretype end group for non-group") 15839 } 15840 if fieldNum <= 0 { 15841 return fmt.Errorf("proto: TransactionMetadata: illegal tag %d (wire type %d)", fieldNum, wire) 15842 } 15843 switch fieldNum { 15844 case 1: 15845 if wireType != 2 { 15846 return fmt.Errorf("proto: wrong wireType = %d for field Dtid", wireType) 15847 } 15848 var stringLen uint64 15849 for shift := uint(0); ; shift += 7 { 15850 if shift >= 64 { 15851 return ErrIntOverflow 15852 } 15853 if iNdEx >= l { 15854 return io.ErrUnexpectedEOF 15855 } 15856 b := dAtA[iNdEx] 15857 iNdEx++ 15858 stringLen |= uint64(b&0x7F) << shift 15859 if b < 0x80 { 15860 break 15861 } 15862 } 15863 intStringLen := int(stringLen) 15864 if intStringLen < 0 { 15865 return ErrInvalidLength 15866 } 15867 postIndex := iNdEx + intStringLen 15868 if postIndex < 0 { 15869 return ErrInvalidLength 15870 } 15871 if postIndex > l { 15872 return io.ErrUnexpectedEOF 15873 } 15874 m.Dtid = string(dAtA[iNdEx:postIndex]) 15875 iNdEx = postIndex 15876 case 2: 15877 if wireType != 0 { 15878 return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) 15879 } 15880 m.State = 0 15881 for shift := uint(0); ; shift += 7 { 15882 if shift >= 64 { 15883 return ErrIntOverflow 15884 } 15885 if iNdEx >= l { 15886 return io.ErrUnexpectedEOF 15887 } 15888 b := dAtA[iNdEx] 15889 iNdEx++ 15890 m.State |= TransactionState(b&0x7F) << shift 15891 if b < 0x80 { 15892 break 15893 } 15894 } 15895 case 3: 15896 if wireType != 0 { 15897 return fmt.Errorf("proto: wrong wireType = %d for field TimeCreated", wireType) 15898 } 15899 m.TimeCreated = 0 15900 for shift := uint(0); ; shift += 7 { 15901 if shift >= 64 { 15902 return ErrIntOverflow 15903 } 15904 if iNdEx >= l { 15905 return io.ErrUnexpectedEOF 15906 } 15907 b := dAtA[iNdEx] 15908 iNdEx++ 15909 m.TimeCreated |= int64(b&0x7F) << shift 15910 if b < 0x80 { 15911 break 15912 } 15913 } 15914 case 4: 15915 if wireType != 2 { 15916 return fmt.Errorf("proto: wrong wireType = %d for field Participants", wireType) 15917 } 15918 var msglen int 15919 for shift := uint(0); ; shift += 7 { 15920 if shift >= 64 { 15921 return ErrIntOverflow 15922 } 15923 if iNdEx >= l { 15924 return io.ErrUnexpectedEOF 15925 } 15926 b := dAtA[iNdEx] 15927 iNdEx++ 15928 msglen |= int(b&0x7F) << shift 15929 if b < 0x80 { 15930 break 15931 } 15932 } 15933 if msglen < 0 { 15934 return ErrInvalidLength 15935 } 15936 postIndex := iNdEx + msglen 15937 if postIndex < 0 { 15938 return ErrInvalidLength 15939 } 15940 if postIndex > l { 15941 return io.ErrUnexpectedEOF 15942 } 15943 m.Participants = append(m.Participants, &Target{}) 15944 if err := m.Participants[len(m.Participants)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { 15945 return err 15946 } 15947 iNdEx = postIndex 15948 default: 15949 iNdEx = preIndex 15950 skippy, err := skip(dAtA[iNdEx:]) 15951 if err != nil { 15952 return err 15953 } 15954 if (skippy < 0) || (iNdEx+skippy) < 0 { 15955 return ErrInvalidLength 15956 } 15957 if (iNdEx + skippy) > l { 15958 return io.ErrUnexpectedEOF 15959 } 15960 m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) 15961 iNdEx += skippy 15962 } 15963 } 15964 15965 if iNdEx > l { 15966 return io.ErrUnexpectedEOF 15967 } 15968 return nil 15969 } 15970 func skip(dAtA []byte) (n int, err error) { 15971 l := len(dAtA) 15972 iNdEx := 0 15973 depth := 0 15974 for iNdEx < l { 15975 var wire uint64 15976 for shift := uint(0); ; shift += 7 { 15977 if shift >= 64 { 15978 return 0, ErrIntOverflow 15979 } 15980 if iNdEx >= l { 15981 return 0, io.ErrUnexpectedEOF 15982 } 15983 b := dAtA[iNdEx] 15984 iNdEx++ 15985 wire |= (uint64(b) & 0x7F) << shift 15986 if b < 0x80 { 15987 break 15988 } 15989 } 15990 wireType := int(wire & 0x7) 15991 switch wireType { 15992 case 0: 15993 for shift := uint(0); ; shift += 7 { 15994 if shift >= 64 { 15995 return 0, ErrIntOverflow 15996 } 15997 if iNdEx >= l { 15998 return 0, io.ErrUnexpectedEOF 15999 } 16000 iNdEx++ 16001 if dAtA[iNdEx-1] < 0x80 { 16002 break 16003 } 16004 } 16005 case 1: 16006 iNdEx += 8 16007 case 2: 16008 var length int 16009 for shift := uint(0); ; shift += 7 { 16010 if shift >= 64 { 16011 return 0, ErrIntOverflow 16012 } 16013 if iNdEx >= l { 16014 return 0, io.ErrUnexpectedEOF 16015 } 16016 b := dAtA[iNdEx] 16017 iNdEx++ 16018 length |= (int(b) & 0x7F) << shift 16019 if b < 0x80 { 16020 break 16021 } 16022 } 16023 if length < 0 { 16024 return 0, ErrInvalidLength 16025 } 16026 iNdEx += length 16027 case 3: 16028 depth++ 16029 case 4: 16030 if depth == 0 { 16031 return 0, ErrUnexpectedEndOfGroup 16032 } 16033 depth-- 16034 case 5: 16035 iNdEx += 4 16036 default: 16037 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 16038 } 16039 if iNdEx < 0 { 16040 return 0, ErrInvalidLength 16041 } 16042 if depth == 0 { 16043 return iNdEx, nil 16044 } 16045 } 16046 return 0, io.ErrUnexpectedEOF 16047 } 16048 16049 var ( 16050 ErrInvalidLength = fmt.Errorf("proto: negative length found during unmarshaling") 16051 ErrIntOverflow = fmt.Errorf("proto: integer overflow") 16052 ErrUnexpectedEndOfGroup = fmt.Errorf("proto: unexpected end of group") 16053 )