From 1969e659d91f755ae71718ebf37757309e8fc45a Mon Sep 17 00:00:00 2001 From: Vicent Marti Date: Tue, 5 Sep 2023 11:27:05 +0200 Subject: [PATCH 1/5] test: fix pb comparisons Signed-off-by: Vicent Marti --- go/vt/vtgate/engine/ordered_aggregate_test.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/go/vt/vtgate/engine/ordered_aggregate_test.go b/go/vt/vtgate/engine/ordered_aggregate_test.go index ba9e3a06ffc..8aa0bf3c3b4 100644 --- a/go/vt/vtgate/engine/ordered_aggregate_test.go +++ b/go/vt/vtgate/engine/ordered_aggregate_test.go @@ -690,7 +690,7 @@ func TestCountDistinctOnVarchar(t *testing.T) { return nil }) require.NoError(t, err) - assert.Equal(t, want, results) + utils.MustMatch(t, want, results) } func TestCountDistinctOnVarcharWithNulls(t *testing.T) { @@ -752,7 +752,7 @@ func TestCountDistinctOnVarcharWithNulls(t *testing.T) { return nil }) require.NoError(t, err) - assert.Equal(t, want, results) + utils.MustMatch(t, want, results) } func TestSumDistinctOnVarcharWithNulls(t *testing.T) { @@ -814,7 +814,7 @@ func TestSumDistinctOnVarcharWithNulls(t *testing.T) { return nil }) require.NoError(t, err) - assert.Equal(t, want, results) + utils.MustMatch(t, want, results) } func TestMultiDistinct(t *testing.T) { @@ -879,7 +879,7 @@ func TestMultiDistinct(t *testing.T) { return nil }) require.NoError(t, err) - assert.Equal(t, want, results) + utils.MustMatch(t, want, results) } func TestOrderedAggregateCollate(t *testing.T) { @@ -1086,7 +1086,7 @@ func TestGroupConcatWithAggrOnEngine(t *testing.T) { return nil }) require.NoError(t, err) - assert.Equal(t, tcase.expResult, results) + utils.MustMatch(t, tcase.expResult, results) }) } } From 4e8e05e4fd3b7d9a315fb790fe6ea747d4c5f2b5 Mon Sep 17 00:00:00 2001 From: Vicent Marti Date: Tue, 5 Sep 2023 10:41:05 +0200 Subject: [PATCH 2/5] mod: update vtprotobuf Signed-off-by: Vicent Marti --- Makefile | 2 +- go.mod | 2 +- go.sum | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Makefile b/Makefile index 3fea94c973f..e8761f127ed 100644 --- a/Makefile +++ b/Makefile @@ -264,7 +264,7 @@ $(PROTO_GO_OUTS): minimaltools install_protoc-gen-go proto/*.proto --go_out=. --plugin protoc-gen-go="${VTROOTBIN}/protoc-gen-go" \ --go-grpc_out=. --plugin protoc-gen-go-grpc="${VTROOTBIN}/protoc-gen-go-grpc" \ --go-vtproto_out=. --plugin protoc-gen-go-vtproto="${VTROOTBIN}/protoc-gen-go-vtproto" \ - --go-vtproto_opt=features=marshal+unmarshal+size+pool \ + --go-vtproto_opt=features=marshal+unmarshal+size+pool+clone \ --go-vtproto_opt=pool=vitess.io/vitess/go/vt/proto/query.Row \ --go-vtproto_opt=pool=vitess.io/vitess/go/vt/proto/binlogdata.VStreamRowsResponse \ -I${PWD}/dist/vt-protoc-21.3/include:proto $(PROTO_SRCS) diff --git a/go.mod b/go.mod index 26c9a81d84a..9b2692ed3b7 100644 --- a/go.mod +++ b/go.mod @@ -51,7 +51,7 @@ require ( github.com/pires/go-proxyproto v0.6.2 github.com/pkg/errors v0.9.1 github.com/planetscale/pargzip v0.0.0-20201116224723-90c7fc03ea8a - github.com/planetscale/vtprotobuf v0.4.0 + github.com/planetscale/vtprotobuf v0.5.0 github.com/prometheus/client_golang v1.15.1 github.com/prometheus/common v0.43.0 // indirect github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 diff --git a/go.sum b/go.sum index b7cd1967093..b5d7eb888c7 100644 --- a/go.sum +++ b/go.sum @@ -495,8 +495,8 @@ github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINE github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg= github.com/planetscale/pargzip v0.0.0-20201116224723-90c7fc03ea8a h1:y0OpQ4+5tKxeh9+H+2cVgASl9yMZYV9CILinKOiKafA= github.com/planetscale/pargzip v0.0.0-20201116224723-90c7fc03ea8a/go.mod h1:GJFUzQuXIoB2Kjn1ZfDhJr/42D5nWOqRcIQVgCxTuIE= -github.com/planetscale/vtprotobuf v0.4.0 h1:NEI+g4woRaAZgeZ3sAvbtyvMBRjIv5kE7EWYQ8m4JwY= -github.com/planetscale/vtprotobuf v0.4.0/go.mod h1:wm1N3qk9G/4+VM1WhpkLbvY/d8+0PbwYYpP5P5VhTks= +github.com/planetscale/vtprotobuf v0.5.0 h1:l8PXm6Colok5z6qQLNhAj2Jq5BfoMTIHxLER5a6nDqM= +github.com/planetscale/vtprotobuf v0.5.0/go.mod h1:wm1N3qk9G/4+VM1WhpkLbvY/d8+0PbwYYpP5P5VhTks= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI= From 55df2a5fed9926ec434aeb5615a2112514190b0b Mon Sep 17 00:00:00 2001 From: Vicent Marti Date: Tue, 5 Sep 2023 10:41:42 +0200 Subject: [PATCH 3/5] proto: update generated files Signed-off-by: Vicent Marti --- .../proto/binlogdata/binlogdata_vtproto.pb.go | 787 ++- go/vt/proto/logutil/logutil_vtproto.pb.go | 25 +- go/vt/proto/mysqlctl/mysqlctl_vtproto.pb.go | 307 +- go/vt/proto/query/query_vtproto.pb.go | 1484 +++++- .../replicationdata_vtproto.pb.go | 118 +- go/vt/proto/tableacl/tableacl_vtproto.pb.go | 64 +- .../tabletmanagerdata_vtproto.pb.go | 2238 +++++++- .../throttlerdata/throttlerdata_vtproto.pb.go | 233 +- go/vt/proto/topodata/topodata_vtproto.pb.go | 566 +- go/vt/proto/vschema/vschema_vtproto.pb.go | 276 +- go/vt/proto/vtadmin/vtadmin_vtproto.pb.go | 2341 ++++++++- go/vt/proto/vtctldata/vtctldata_vtproto.pb.go | 4621 ++++++++++++++++- go/vt/proto/vtgate/vtgate_vtproto.pb.go | 476 +- go/vt/proto/vtrpc/vtrpc_vtproto.pb.go | 47 +- go/vt/proto/vttest/vttest_vtproto.pb.go | 80 +- go/vt/proto/vttime/vttime_vtproto.pb.go | 41 +- 16 files changed, 13688 insertions(+), 16 deletions(-) diff --git a/go/vt/proto/binlogdata/binlogdata_vtproto.pb.go b/go/vt/proto/binlogdata/binlogdata_vtproto.pb.go index 926ea5434c8..78c7faa0e17 100644 --- a/go/vt/proto/binlogdata/binlogdata_vtproto.pb.go +++ b/go/vt/proto/binlogdata/binlogdata_vtproto.pb.go @@ -1,11 +1,12 @@ // Code generated by protoc-gen-go-vtproto. DO NOT EDIT. -// protoc-gen-go-vtproto version: v0.4.0 +// protoc-gen-go-vtproto version: v0.5.0 // source: binlogdata.proto package binlogdata import ( fmt "fmt" + proto "google.golang.org/protobuf/proto" protoimpl "google.golang.org/protobuf/runtime/protoimpl" io "io" bits "math/bits" @@ -22,6 +23,778 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +func (m *Charset) CloneVT() *Charset { + if m == nil { + return (*Charset)(nil) + } + r := &Charset{ + Client: m.Client, + Conn: m.Conn, + Server: m.Server, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Charset) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *BinlogTransaction_Statement) CloneVT() *BinlogTransaction_Statement { + if m == nil { + return (*BinlogTransaction_Statement)(nil) + } + r := &BinlogTransaction_Statement{ + Category: m.Category, + Charset: m.Charset.CloneVT(), + } + if rhs := m.Sql; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.Sql = tmpBytes + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BinlogTransaction_Statement) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *BinlogTransaction) CloneVT() *BinlogTransaction { + if m == nil { + return (*BinlogTransaction)(nil) + } + r := &BinlogTransaction{ + EventToken: m.EventToken.CloneVT(), + } + if rhs := m.Statements; rhs != nil { + tmpContainer := make([]*BinlogTransaction_Statement, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Statements = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BinlogTransaction) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StreamKeyRangeRequest) CloneVT() *StreamKeyRangeRequest { + if m == nil { + return (*StreamKeyRangeRequest)(nil) + } + r := &StreamKeyRangeRequest{ + Position: m.Position, + KeyRange: m.KeyRange.CloneVT(), + Charset: m.Charset.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StreamKeyRangeRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StreamKeyRangeResponse) CloneVT() *StreamKeyRangeResponse { + if m == nil { + return (*StreamKeyRangeResponse)(nil) + } + r := &StreamKeyRangeResponse{ + BinlogTransaction: m.BinlogTransaction.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StreamKeyRangeResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StreamTablesRequest) CloneVT() *StreamTablesRequest { + if m == nil { + return (*StreamTablesRequest)(nil) + } + r := &StreamTablesRequest{ + Position: m.Position, + Charset: m.Charset.CloneVT(), + } + if rhs := m.Tables; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Tables = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StreamTablesRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StreamTablesResponse) CloneVT() *StreamTablesResponse { + if m == nil { + return (*StreamTablesResponse)(nil) + } + r := &StreamTablesResponse{ + BinlogTransaction: m.BinlogTransaction.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StreamTablesResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CharsetConversion) CloneVT() *CharsetConversion { + if m == nil { + return (*CharsetConversion)(nil) + } + r := &CharsetConversion{ + FromCharset: m.FromCharset, + ToCharset: m.ToCharset, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CharsetConversion) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Rule) CloneVT() *Rule { + if m == nil { + return (*Rule)(nil) + } + r := &Rule{ + Match: m.Match, + Filter: m.Filter, + SourceUniqueKeyColumns: m.SourceUniqueKeyColumns, + TargetUniqueKeyColumns: m.TargetUniqueKeyColumns, + SourceUniqueKeyTargetColumns: m.SourceUniqueKeyTargetColumns, + } + if rhs := m.ConvertEnumToText; rhs != nil { + tmpContainer := make(map[string]string, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.ConvertEnumToText = tmpContainer + } + if rhs := m.ConvertCharset; rhs != nil { + tmpContainer := make(map[string]*CharsetConversion, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ConvertCharset = tmpContainer + } + if rhs := m.ConvertIntToEnum; rhs != nil { + tmpContainer := make(map[string]bool, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.ConvertIntToEnum = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Rule) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Filter) CloneVT() *Filter { + if m == nil { + return (*Filter)(nil) + } + r := &Filter{ + FieldEventMode: m.FieldEventMode, + WorkflowType: m.WorkflowType, + WorkflowName: m.WorkflowName, + } + if rhs := m.Rules; rhs != nil { + tmpContainer := make([]*Rule, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Rules = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Filter) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *BinlogSource) CloneVT() *BinlogSource { + if m == nil { + return (*BinlogSource)(nil) + } + r := &BinlogSource{ + Keyspace: m.Keyspace, + Shard: m.Shard, + TabletType: m.TabletType, + KeyRange: m.KeyRange.CloneVT(), + Filter: m.Filter.CloneVT(), + OnDdl: m.OnDdl, + ExternalMysql: m.ExternalMysql, + StopAfterCopy: m.StopAfterCopy, + ExternalCluster: m.ExternalCluster, + SourceTimeZone: m.SourceTimeZone, + TargetTimeZone: m.TargetTimeZone, + } + if rhs := m.Tables; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Tables = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BinlogSource) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RowChange_Bitmap) CloneVT() *RowChange_Bitmap { + if m == nil { + return (*RowChange_Bitmap)(nil) + } + r := &RowChange_Bitmap{ + Count: m.Count, + } + if rhs := m.Cols; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.Cols = tmpBytes + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RowChange_Bitmap) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RowChange) CloneVT() *RowChange { + if m == nil { + return (*RowChange)(nil) + } + r := &RowChange{ + Before: m.Before.CloneVT(), + After: m.After.CloneVT(), + DataColumns: m.DataColumns.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RowChange) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RowEvent) CloneVT() *RowEvent { + if m == nil { + return (*RowEvent)(nil) + } + r := &RowEvent{ + TableName: m.TableName, + Keyspace: m.Keyspace, + Shard: m.Shard, + } + if rhs := m.RowChanges; rhs != nil { + tmpContainer := make([]*RowChange, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.RowChanges = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RowEvent) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *FieldEvent) CloneVT() *FieldEvent { + if m == nil { + return (*FieldEvent)(nil) + } + r := &FieldEvent{ + TableName: m.TableName, + Keyspace: m.Keyspace, + Shard: m.Shard, + } + if rhs := m.Fields; rhs != nil { + tmpContainer := make([]*query.Field, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Fields = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *FieldEvent) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ShardGtid) CloneVT() *ShardGtid { + if m == nil { + return (*ShardGtid)(nil) + } + r := &ShardGtid{ + Keyspace: m.Keyspace, + Shard: m.Shard, + Gtid: m.Gtid, + } + if rhs := m.TablePKs; rhs != nil { + tmpContainer := make([]*TableLastPK, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.TablePKs = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ShardGtid) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VGtid) CloneVT() *VGtid { + if m == nil { + return (*VGtid)(nil) + } + r := &VGtid{} + if rhs := m.ShardGtids; rhs != nil { + tmpContainer := make([]*ShardGtid, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ShardGtids = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VGtid) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *KeyspaceShard) CloneVT() *KeyspaceShard { + if m == nil { + return (*KeyspaceShard)(nil) + } + r := &KeyspaceShard{ + Keyspace: m.Keyspace, + Shard: m.Shard, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *KeyspaceShard) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Journal) CloneVT() *Journal { + if m == nil { + return (*Journal)(nil) + } + r := &Journal{ + Id: m.Id, + MigrationType: m.MigrationType, + LocalPosition: m.LocalPosition, + } + if rhs := m.Tables; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Tables = tmpContainer + } + if rhs := m.ShardGtids; rhs != nil { + tmpContainer := make([]*ShardGtid, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ShardGtids = tmpContainer + } + if rhs := m.Participants; rhs != nil { + tmpContainer := make([]*KeyspaceShard, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Participants = tmpContainer + } + if rhs := m.SourceWorkflows; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.SourceWorkflows = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Journal) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VEvent) CloneVT() *VEvent { + if m == nil { + return (*VEvent)(nil) + } + r := &VEvent{ + Type: m.Type, + Timestamp: m.Timestamp, + Gtid: m.Gtid, + Statement: m.Statement, + RowEvent: m.RowEvent.CloneVT(), + FieldEvent: m.FieldEvent.CloneVT(), + Vgtid: m.Vgtid.CloneVT(), + Journal: m.Journal.CloneVT(), + Dml: m.Dml, + CurrentTime: m.CurrentTime, + LastPKEvent: m.LastPKEvent.CloneVT(), + Keyspace: m.Keyspace, + Shard: m.Shard, + Throttled: m.Throttled, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VEvent) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *MinimalTable) CloneVT() *MinimalTable { + if m == nil { + return (*MinimalTable)(nil) + } + r := &MinimalTable{ + Name: m.Name, + } + if rhs := m.Fields; rhs != nil { + tmpContainer := make([]*query.Field, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Fields = tmpContainer + } + if rhs := m.PKColumns; rhs != nil { + tmpContainer := make([]int64, len(rhs)) + copy(tmpContainer, rhs) + r.PKColumns = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *MinimalTable) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *MinimalSchema) CloneVT() *MinimalSchema { + if m == nil { + return (*MinimalSchema)(nil) + } + r := &MinimalSchema{} + if rhs := m.Tables; rhs != nil { + tmpContainer := make([]*MinimalTable, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Tables = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *MinimalSchema) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VStreamRequest) CloneVT() *VStreamRequest { + if m == nil { + return (*VStreamRequest)(nil) + } + r := &VStreamRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + Position: m.Position, + Filter: m.Filter.CloneVT(), + } + if rhs := m.TableLastPKs; rhs != nil { + tmpContainer := make([]*TableLastPK, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.TableLastPKs = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VStreamRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VStreamResponse) CloneVT() *VStreamResponse { + if m == nil { + return (*VStreamResponse)(nil) + } + r := &VStreamResponse{} + if rhs := m.Events; rhs != nil { + tmpContainer := make([]*VEvent, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Events = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VStreamResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VStreamRowsRequest) CloneVT() *VStreamRowsRequest { + if m == nil { + return (*VStreamRowsRequest)(nil) + } + r := &VStreamRowsRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + Query: m.Query, + Lastpk: m.Lastpk.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VStreamRowsRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VStreamRowsResponse) CloneVT() *VStreamRowsResponse { + if m == nil { + return (*VStreamRowsResponse)(nil) + } + r := &VStreamRowsResponse{ + Gtid: m.Gtid, + Lastpk: m.Lastpk.CloneVT(), + Throttled: m.Throttled, + Heartbeat: m.Heartbeat, + } + if rhs := m.Fields; rhs != nil { + tmpContainer := make([]*query.Field, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Fields = tmpContainer + } + if rhs := m.Pkfields; rhs != nil { + tmpContainer := make([]*query.Field, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Pkfields = tmpContainer + } + if rhs := m.Rows; rhs != nil { + tmpContainer := make([]*query.Row, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Rows = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VStreamRowsResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *LastPKEvent) CloneVT() *LastPKEvent { + if m == nil { + return (*LastPKEvent)(nil) + } + r := &LastPKEvent{ + TableLastPK: m.TableLastPK.CloneVT(), + Completed: m.Completed, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *LastPKEvent) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *TableLastPK) CloneVT() *TableLastPK { + if m == nil { + return (*TableLastPK)(nil) + } + r := &TableLastPK{ + TableName: m.TableName, + Lastpk: m.Lastpk.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *TableLastPK) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VStreamResultsRequest) CloneVT() *VStreamResultsRequest { + if m == nil { + return (*VStreamResultsRequest)(nil) + } + r := &VStreamResultsRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + Query: m.Query, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VStreamResultsRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VStreamResultsResponse) CloneVT() *VStreamResultsResponse { + if m == nil { + return (*VStreamResultsResponse)(nil) + } + r := &VStreamResultsResponse{ + Gtid: m.Gtid, + } + if rhs := m.Fields; rhs != nil { + tmpContainer := make([]*query.Field, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Fields = tmpContainer + } + if rhs := m.Rows; rhs != nil { + tmpContainer := make([]*query.Row, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Rows = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VStreamResultsResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + func (m *Charset) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil @@ -2089,11 +2862,23 @@ var vtprotoPool_VStreamRowsResponse = sync.Pool{ } func (m *VStreamRowsResponse) ResetVT() { + for _, mm := range m.Fields { + mm.Reset() + } + f0 := m.Fields[:0] + for _, mm := range m.Pkfields { + mm.Reset() + } + f1 := m.Pkfields[:0] for _, mm := range m.Rows { mm.ResetVT() } + f2 := m.Rows[:0] m.Lastpk.ReturnToVTPool() m.Reset() + m.Fields = f0 + m.Pkfields = f1 + m.Rows = f2 } func (m *VStreamRowsResponse) ReturnToVTPool() { if m != nil { diff --git a/go/vt/proto/logutil/logutil_vtproto.pb.go b/go/vt/proto/logutil/logutil_vtproto.pb.go index 234c26eea93..1d3ccb74271 100644 --- a/go/vt/proto/logutil/logutil_vtproto.pb.go +++ b/go/vt/proto/logutil/logutil_vtproto.pb.go @@ -1,11 +1,12 @@ // Code generated by protoc-gen-go-vtproto. DO NOT EDIT. -// protoc-gen-go-vtproto version: v0.4.0 +// protoc-gen-go-vtproto version: v0.5.0 // source: logutil.proto package logutil import ( fmt "fmt" + proto "google.golang.org/protobuf/proto" protoimpl "google.golang.org/protobuf/runtime/protoimpl" io "io" bits "math/bits" @@ -19,6 +20,28 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +func (m *Event) CloneVT() *Event { + if m == nil { + return (*Event)(nil) + } + r := &Event{ + Time: m.Time.CloneVT(), + Level: m.Level, + File: m.File, + Line: m.Line, + Value: m.Value, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Event) CloneMessageVT() proto.Message { + return m.CloneVT() +} + func (m *Event) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil diff --git a/go/vt/proto/mysqlctl/mysqlctl_vtproto.pb.go b/go/vt/proto/mysqlctl/mysqlctl_vtproto.pb.go index 0c9856b164c..bb2ec78e03a 100644 --- a/go/vt/proto/mysqlctl/mysqlctl_vtproto.pb.go +++ b/go/vt/proto/mysqlctl/mysqlctl_vtproto.pb.go @@ -1,11 +1,12 @@ // Code generated by protoc-gen-go-vtproto. DO NOT EDIT. -// protoc-gen-go-vtproto version: v0.4.0 +// protoc-gen-go-vtproto version: v0.5.0 // source: mysqlctl.proto package mysqlctl import ( fmt "fmt" + proto "google.golang.org/protobuf/proto" protoimpl "google.golang.org/protobuf/runtime/protoimpl" io "io" bits "math/bits" @@ -20,6 +21,310 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +func (m *StartRequest) CloneVT() *StartRequest { + if m == nil { + return (*StartRequest)(nil) + } + r := &StartRequest{} + if rhs := m.MysqldArgs; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.MysqldArgs = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StartRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StartResponse) CloneVT() *StartResponse { + if m == nil { + return (*StartResponse)(nil) + } + r := &StartResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StartResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ShutdownRequest) CloneVT() *ShutdownRequest { + if m == nil { + return (*ShutdownRequest)(nil) + } + r := &ShutdownRequest{ + WaitForMysqld: m.WaitForMysqld, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ShutdownRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ShutdownResponse) CloneVT() *ShutdownResponse { + if m == nil { + return (*ShutdownResponse)(nil) + } + r := &ShutdownResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ShutdownResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RunMysqlUpgradeRequest) CloneVT() *RunMysqlUpgradeRequest { + if m == nil { + return (*RunMysqlUpgradeRequest)(nil) + } + r := &RunMysqlUpgradeRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RunMysqlUpgradeRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RunMysqlUpgradeResponse) CloneVT() *RunMysqlUpgradeResponse { + if m == nil { + return (*RunMysqlUpgradeResponse)(nil) + } + r := &RunMysqlUpgradeResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RunMysqlUpgradeResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ApplyBinlogFileRequest) CloneVT() *ApplyBinlogFileRequest { + if m == nil { + return (*ApplyBinlogFileRequest)(nil) + } + r := &ApplyBinlogFileRequest{ + BinlogFileName: m.BinlogFileName, + BinlogRestorePosition: m.BinlogRestorePosition, + BinlogRestoreDatetime: m.BinlogRestoreDatetime.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ApplyBinlogFileRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ApplyBinlogFileResponse) CloneVT() *ApplyBinlogFileResponse { + if m == nil { + return (*ApplyBinlogFileResponse)(nil) + } + r := &ApplyBinlogFileResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ApplyBinlogFileResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReadBinlogFilesTimestampsRequest) CloneVT() *ReadBinlogFilesTimestampsRequest { + if m == nil { + return (*ReadBinlogFilesTimestampsRequest)(nil) + } + r := &ReadBinlogFilesTimestampsRequest{} + if rhs := m.BinlogFileNames; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.BinlogFileNames = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReadBinlogFilesTimestampsRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReadBinlogFilesTimestampsResponse) CloneVT() *ReadBinlogFilesTimestampsResponse { + if m == nil { + return (*ReadBinlogFilesTimestampsResponse)(nil) + } + r := &ReadBinlogFilesTimestampsResponse{ + FirstTimestamp: m.FirstTimestamp.CloneVT(), + FirstTimestampBinlog: m.FirstTimestampBinlog, + LastTimestamp: m.LastTimestamp.CloneVT(), + LastTimestampBinlog: m.LastTimestampBinlog, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReadBinlogFilesTimestampsResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReinitConfigRequest) CloneVT() *ReinitConfigRequest { + if m == nil { + return (*ReinitConfigRequest)(nil) + } + r := &ReinitConfigRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReinitConfigRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReinitConfigResponse) CloneVT() *ReinitConfigResponse { + if m == nil { + return (*ReinitConfigResponse)(nil) + } + r := &ReinitConfigResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReinitConfigResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RefreshConfigRequest) CloneVT() *RefreshConfigRequest { + if m == nil { + return (*RefreshConfigRequest)(nil) + } + r := &RefreshConfigRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RefreshConfigRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RefreshConfigResponse) CloneVT() *RefreshConfigResponse { + if m == nil { + return (*RefreshConfigResponse)(nil) + } + r := &RefreshConfigResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RefreshConfigResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VersionStringRequest) CloneVT() *VersionStringRequest { + if m == nil { + return (*VersionStringRequest)(nil) + } + r := &VersionStringRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VersionStringRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VersionStringResponse) CloneVT() *VersionStringResponse { + if m == nil { + return (*VersionStringResponse)(nil) + } + r := &VersionStringResponse{ + Version: m.Version, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VersionStringResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *BackupInfo) CloneVT() *BackupInfo { + if m == nil { + return (*BackupInfo)(nil) + } + r := &BackupInfo{ + Name: m.Name, + Directory: m.Directory, + Keyspace: m.Keyspace, + Shard: m.Shard, + TabletAlias: m.TabletAlias.CloneVT(), + Time: m.Time.CloneVT(), + Engine: m.Engine, + Status: m.Status, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BackupInfo) CloneMessageVT() proto.Message { + return m.CloneVT() +} + func (m *StartRequest) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil diff --git a/go/vt/proto/query/query_vtproto.pb.go b/go/vt/proto/query/query_vtproto.pb.go index 243981a832a..2da0324bab0 100644 --- a/go/vt/proto/query/query_vtproto.pb.go +++ b/go/vt/proto/query/query_vtproto.pb.go @@ -1,5 +1,5 @@ // Code generated by protoc-gen-go-vtproto. DO NOT EDIT. -// protoc-gen-go-vtproto version: v0.4.0 +// protoc-gen-go-vtproto version: v0.5.0 // source: query.proto package query @@ -7,6 +7,7 @@ package query import ( binary "encoding/binary" fmt "fmt" + proto "google.golang.org/protobuf/proto" protoimpl "google.golang.org/protobuf/runtime/protoimpl" io "io" math "math" @@ -23,6 +24,1487 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +func (m *Target) CloneVT() *Target { + if m == nil { + return (*Target)(nil) + } + r := &Target{ + Keyspace: m.Keyspace, + Shard: m.Shard, + TabletType: m.TabletType, + Cell: m.Cell, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Target) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VTGateCallerID) CloneVT() *VTGateCallerID { + if m == nil { + return (*VTGateCallerID)(nil) + } + r := &VTGateCallerID{ + Username: m.Username, + } + if rhs := m.Groups; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Groups = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VTGateCallerID) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *EventToken) CloneVT() *EventToken { + if m == nil { + return (*EventToken)(nil) + } + r := &EventToken{ + Timestamp: m.Timestamp, + Shard: m.Shard, + Position: m.Position, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *EventToken) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Value) CloneVT() *Value { + if m == nil { + return (*Value)(nil) + } + r := &Value{ + Type: m.Type, + } + if rhs := m.Value; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.Value = tmpBytes + } + if rhs := m.Values; rhs != nil { + tmpContainer := make([]*Value, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Values = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Value) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *BindVariable) CloneVT() *BindVariable { + if m == nil { + return (*BindVariable)(nil) + } + r := &BindVariable{ + Type: m.Type, + } + if rhs := m.Value; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.Value = tmpBytes + } + if rhs := m.Values; rhs != nil { + tmpContainer := make([]*Value, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Values = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BindVariable) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *BoundQuery) CloneVT() *BoundQuery { + if m == nil { + return (*BoundQuery)(nil) + } + r := &BoundQuery{ + Sql: m.Sql, + } + if rhs := m.BindVariables; rhs != nil { + tmpContainer := make(map[string]*BindVariable, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.BindVariables = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BoundQuery) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteOptions) CloneVT() *ExecuteOptions { + if m == nil { + return (*ExecuteOptions)(nil) + } + r := &ExecuteOptions{ + IncludedFields: m.IncludedFields, + ClientFoundRows: m.ClientFoundRows, + Workload: m.Workload, + SqlSelectLimit: m.SqlSelectLimit, + TransactionIsolation: m.TransactionIsolation, + SkipQueryPlanCache: m.SkipQueryPlanCache, + PlannerVersion: m.PlannerVersion, + HasCreatedTempTables: m.HasCreatedTempTables, + Consolidator: m.Consolidator, + WorkloadName: m.WorkloadName, + Priority: m.Priority, + } + if rhs := m.TransactionAccessMode; rhs != nil { + tmpContainer := make([]ExecuteOptions_TransactionAccessMode, len(rhs)) + copy(tmpContainer, rhs) + r.TransactionAccessMode = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteOptions) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Field) CloneVT() *Field { + if m == nil { + return (*Field)(nil) + } + r := &Field{ + Name: m.Name, + Type: m.Type, + Table: m.Table, + OrgTable: m.OrgTable, + Database: m.Database, + OrgName: m.OrgName, + ColumnLength: m.ColumnLength, + Charset: m.Charset, + Decimals: m.Decimals, + Flags: m.Flags, + ColumnType: m.ColumnType, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Field) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Row) CloneVT() *Row { + if m == nil { + return (*Row)(nil) + } + r := &Row{} + if rhs := m.Lengths; rhs != nil { + tmpContainer := make([]int64, len(rhs)) + copy(tmpContainer, rhs) + r.Lengths = tmpContainer + } + if rhs := m.Values; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.Values = tmpBytes + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Row) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *QueryResult) CloneVT() *QueryResult { + if m == nil { + return (*QueryResult)(nil) + } + r := &QueryResult{ + RowsAffected: m.RowsAffected, + InsertId: m.InsertId, + Info: m.Info, + SessionStateChanges: m.SessionStateChanges, + } + if rhs := m.Fields; rhs != nil { + tmpContainer := make([]*Field, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Fields = tmpContainer + } + if rhs := m.Rows; rhs != nil { + tmpContainer := make([]*Row, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Rows = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *QueryResult) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *QueryWarning) CloneVT() *QueryWarning { + if m == nil { + return (*QueryWarning)(nil) + } + r := &QueryWarning{ + Code: m.Code, + Message: m.Message, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *QueryWarning) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StreamEvent_Statement) CloneVT() *StreamEvent_Statement { + if m == nil { + return (*StreamEvent_Statement)(nil) + } + r := &StreamEvent_Statement{ + Category: m.Category, + TableName: m.TableName, + } + if rhs := m.PrimaryKeyFields; rhs != nil { + tmpContainer := make([]*Field, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.PrimaryKeyFields = tmpContainer + } + if rhs := m.PrimaryKeyValues; rhs != nil { + tmpContainer := make([]*Row, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.PrimaryKeyValues = tmpContainer + } + if rhs := m.Sql; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.Sql = tmpBytes + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StreamEvent_Statement) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StreamEvent) CloneVT() *StreamEvent { + if m == nil { + return (*StreamEvent)(nil) + } + r := &StreamEvent{ + EventToken: m.EventToken.CloneVT(), + } + if rhs := m.Statements; rhs != nil { + tmpContainer := make([]*StreamEvent_Statement, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Statements = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StreamEvent) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteRequest) CloneVT() *ExecuteRequest { + if m == nil { + return (*ExecuteRequest)(nil) + } + r := &ExecuteRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + Query: m.Query.CloneVT(), + TransactionId: m.TransactionId, + Options: m.Options.CloneVT(), + ReservedId: m.ReservedId, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteResponse) CloneVT() *ExecuteResponse { + if m == nil { + return (*ExecuteResponse)(nil) + } + r := &ExecuteResponse{ + Result: m.Result.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ResultWithError) CloneVT() *ResultWithError { + if m == nil { + return (*ResultWithError)(nil) + } + r := &ResultWithError{ + Error: m.Error.CloneVT(), + Result: m.Result.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ResultWithError) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StreamExecuteRequest) CloneVT() *StreamExecuteRequest { + if m == nil { + return (*StreamExecuteRequest)(nil) + } + r := &StreamExecuteRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + Query: m.Query.CloneVT(), + Options: m.Options.CloneVT(), + TransactionId: m.TransactionId, + ReservedId: m.ReservedId, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StreamExecuteRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StreamExecuteResponse) CloneVT() *StreamExecuteResponse { + if m == nil { + return (*StreamExecuteResponse)(nil) + } + r := &StreamExecuteResponse{ + Result: m.Result.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StreamExecuteResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *BeginRequest) CloneVT() *BeginRequest { + if m == nil { + return (*BeginRequest)(nil) + } + r := &BeginRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + Options: m.Options.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BeginRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *BeginResponse) CloneVT() *BeginResponse { + if m == nil { + return (*BeginResponse)(nil) + } + r := &BeginResponse{ + TransactionId: m.TransactionId, + TabletAlias: m.TabletAlias.CloneVT(), + SessionStateChanges: m.SessionStateChanges, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BeginResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CommitRequest) CloneVT() *CommitRequest { + if m == nil { + return (*CommitRequest)(nil) + } + r := &CommitRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + TransactionId: m.TransactionId, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CommitRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CommitResponse) CloneVT() *CommitResponse { + if m == nil { + return (*CommitResponse)(nil) + } + r := &CommitResponse{ + ReservedId: m.ReservedId, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CommitResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RollbackRequest) CloneVT() *RollbackRequest { + if m == nil { + return (*RollbackRequest)(nil) + } + r := &RollbackRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + TransactionId: m.TransactionId, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RollbackRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RollbackResponse) CloneVT() *RollbackResponse { + if m == nil { + return (*RollbackResponse)(nil) + } + r := &RollbackResponse{ + ReservedId: m.ReservedId, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RollbackResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PrepareRequest) CloneVT() *PrepareRequest { + if m == nil { + return (*PrepareRequest)(nil) + } + r := &PrepareRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + TransactionId: m.TransactionId, + Dtid: m.Dtid, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PrepareRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PrepareResponse) CloneVT() *PrepareResponse { + if m == nil { + return (*PrepareResponse)(nil) + } + r := &PrepareResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PrepareResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CommitPreparedRequest) CloneVT() *CommitPreparedRequest { + if m == nil { + return (*CommitPreparedRequest)(nil) + } + r := &CommitPreparedRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + Dtid: m.Dtid, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CommitPreparedRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CommitPreparedResponse) CloneVT() *CommitPreparedResponse { + if m == nil { + return (*CommitPreparedResponse)(nil) + } + r := &CommitPreparedResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CommitPreparedResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RollbackPreparedRequest) CloneVT() *RollbackPreparedRequest { + if m == nil { + return (*RollbackPreparedRequest)(nil) + } + r := &RollbackPreparedRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + TransactionId: m.TransactionId, + Dtid: m.Dtid, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RollbackPreparedRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RollbackPreparedResponse) CloneVT() *RollbackPreparedResponse { + if m == nil { + return (*RollbackPreparedResponse)(nil) + } + r := &RollbackPreparedResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RollbackPreparedResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CreateTransactionRequest) CloneVT() *CreateTransactionRequest { + if m == nil { + return (*CreateTransactionRequest)(nil) + } + r := &CreateTransactionRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + Dtid: m.Dtid, + } + if rhs := m.Participants; rhs != nil { + tmpContainer := make([]*Target, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Participants = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CreateTransactionRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CreateTransactionResponse) CloneVT() *CreateTransactionResponse { + if m == nil { + return (*CreateTransactionResponse)(nil) + } + r := &CreateTransactionResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CreateTransactionResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StartCommitRequest) CloneVT() *StartCommitRequest { + if m == nil { + return (*StartCommitRequest)(nil) + } + r := &StartCommitRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + TransactionId: m.TransactionId, + Dtid: m.Dtid, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StartCommitRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StartCommitResponse) CloneVT() *StartCommitResponse { + if m == nil { + return (*StartCommitResponse)(nil) + } + r := &StartCommitResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StartCommitResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetRollbackRequest) CloneVT() *SetRollbackRequest { + if m == nil { + return (*SetRollbackRequest)(nil) + } + r := &SetRollbackRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + TransactionId: m.TransactionId, + Dtid: m.Dtid, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetRollbackRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetRollbackResponse) CloneVT() *SetRollbackResponse { + if m == nil { + return (*SetRollbackResponse)(nil) + } + r := &SetRollbackResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetRollbackResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ConcludeTransactionRequest) CloneVT() *ConcludeTransactionRequest { + if m == nil { + return (*ConcludeTransactionRequest)(nil) + } + r := &ConcludeTransactionRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + Dtid: m.Dtid, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ConcludeTransactionRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ConcludeTransactionResponse) CloneVT() *ConcludeTransactionResponse { + if m == nil { + return (*ConcludeTransactionResponse)(nil) + } + r := &ConcludeTransactionResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ConcludeTransactionResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReadTransactionRequest) CloneVT() *ReadTransactionRequest { + if m == nil { + return (*ReadTransactionRequest)(nil) + } + r := &ReadTransactionRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + Dtid: m.Dtid, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReadTransactionRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReadTransactionResponse) CloneVT() *ReadTransactionResponse { + if m == nil { + return (*ReadTransactionResponse)(nil) + } + r := &ReadTransactionResponse{ + Metadata: m.Metadata.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReadTransactionResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *BeginExecuteRequest) CloneVT() *BeginExecuteRequest { + if m == nil { + return (*BeginExecuteRequest)(nil) + } + r := &BeginExecuteRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + Query: m.Query.CloneVT(), + Options: m.Options.CloneVT(), + ReservedId: m.ReservedId, + } + if rhs := m.PreQueries; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.PreQueries = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BeginExecuteRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *BeginExecuteResponse) CloneVT() *BeginExecuteResponse { + if m == nil { + return (*BeginExecuteResponse)(nil) + } + r := &BeginExecuteResponse{ + Error: m.Error.CloneVT(), + Result: m.Result.CloneVT(), + TransactionId: m.TransactionId, + TabletAlias: m.TabletAlias.CloneVT(), + SessionStateChanges: m.SessionStateChanges, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BeginExecuteResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *BeginStreamExecuteRequest) CloneVT() *BeginStreamExecuteRequest { + if m == nil { + return (*BeginStreamExecuteRequest)(nil) + } + r := &BeginStreamExecuteRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + Query: m.Query.CloneVT(), + Options: m.Options.CloneVT(), + ReservedId: m.ReservedId, + } + if rhs := m.PreQueries; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.PreQueries = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BeginStreamExecuteRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *BeginStreamExecuteResponse) CloneVT() *BeginStreamExecuteResponse { + if m == nil { + return (*BeginStreamExecuteResponse)(nil) + } + r := &BeginStreamExecuteResponse{ + Error: m.Error.CloneVT(), + Result: m.Result.CloneVT(), + TransactionId: m.TransactionId, + TabletAlias: m.TabletAlias.CloneVT(), + SessionStateChanges: m.SessionStateChanges, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BeginStreamExecuteResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *MessageStreamRequest) CloneVT() *MessageStreamRequest { + if m == nil { + return (*MessageStreamRequest)(nil) + } + r := &MessageStreamRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + Name: m.Name, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *MessageStreamRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *MessageStreamResponse) CloneVT() *MessageStreamResponse { + if m == nil { + return (*MessageStreamResponse)(nil) + } + r := &MessageStreamResponse{ + Result: m.Result.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *MessageStreamResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *MessageAckRequest) CloneVT() *MessageAckRequest { + if m == nil { + return (*MessageAckRequest)(nil) + } + r := &MessageAckRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + Name: m.Name, + } + if rhs := m.Ids; rhs != nil { + tmpContainer := make([]*Value, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Ids = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *MessageAckRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *MessageAckResponse) CloneVT() *MessageAckResponse { + if m == nil { + return (*MessageAckResponse)(nil) + } + r := &MessageAckResponse{ + Result: m.Result.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *MessageAckResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReserveExecuteRequest) CloneVT() *ReserveExecuteRequest { + if m == nil { + return (*ReserveExecuteRequest)(nil) + } + r := &ReserveExecuteRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + Query: m.Query.CloneVT(), + TransactionId: m.TransactionId, + Options: m.Options.CloneVT(), + } + if rhs := m.PreQueries; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.PreQueries = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReserveExecuteRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReserveExecuteResponse) CloneVT() *ReserveExecuteResponse { + if m == nil { + return (*ReserveExecuteResponse)(nil) + } + r := &ReserveExecuteResponse{ + Error: m.Error.CloneVT(), + Result: m.Result.CloneVT(), + ReservedId: m.ReservedId, + TabletAlias: m.TabletAlias.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReserveExecuteResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReserveStreamExecuteRequest) CloneVT() *ReserveStreamExecuteRequest { + if m == nil { + return (*ReserveStreamExecuteRequest)(nil) + } + r := &ReserveStreamExecuteRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + Query: m.Query.CloneVT(), + Options: m.Options.CloneVT(), + TransactionId: m.TransactionId, + } + if rhs := m.PreQueries; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.PreQueries = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReserveStreamExecuteRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReserveStreamExecuteResponse) CloneVT() *ReserveStreamExecuteResponse { + if m == nil { + return (*ReserveStreamExecuteResponse)(nil) + } + r := &ReserveStreamExecuteResponse{ + Error: m.Error.CloneVT(), + Result: m.Result.CloneVT(), + ReservedId: m.ReservedId, + TabletAlias: m.TabletAlias.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReserveStreamExecuteResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReserveBeginExecuteRequest) CloneVT() *ReserveBeginExecuteRequest { + if m == nil { + return (*ReserveBeginExecuteRequest)(nil) + } + r := &ReserveBeginExecuteRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + Query: m.Query.CloneVT(), + Options: m.Options.CloneVT(), + } + if rhs := m.PreQueries; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.PreQueries = tmpContainer + } + if rhs := m.PostBeginQueries; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.PostBeginQueries = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReserveBeginExecuteRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReserveBeginExecuteResponse) CloneVT() *ReserveBeginExecuteResponse { + if m == nil { + return (*ReserveBeginExecuteResponse)(nil) + } + r := &ReserveBeginExecuteResponse{ + Error: m.Error.CloneVT(), + Result: m.Result.CloneVT(), + TransactionId: m.TransactionId, + ReservedId: m.ReservedId, + TabletAlias: m.TabletAlias.CloneVT(), + SessionStateChanges: m.SessionStateChanges, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReserveBeginExecuteResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReserveBeginStreamExecuteRequest) CloneVT() *ReserveBeginStreamExecuteRequest { + if m == nil { + return (*ReserveBeginStreamExecuteRequest)(nil) + } + r := &ReserveBeginStreamExecuteRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + Query: m.Query.CloneVT(), + Options: m.Options.CloneVT(), + } + if rhs := m.PreQueries; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.PreQueries = tmpContainer + } + if rhs := m.PostBeginQueries; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.PostBeginQueries = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReserveBeginStreamExecuteRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReserveBeginStreamExecuteResponse) CloneVT() *ReserveBeginStreamExecuteResponse { + if m == nil { + return (*ReserveBeginStreamExecuteResponse)(nil) + } + r := &ReserveBeginStreamExecuteResponse{ + Error: m.Error.CloneVT(), + Result: m.Result.CloneVT(), + TransactionId: m.TransactionId, + ReservedId: m.ReservedId, + TabletAlias: m.TabletAlias.CloneVT(), + SessionStateChanges: m.SessionStateChanges, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReserveBeginStreamExecuteResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReleaseRequest) CloneVT() *ReleaseRequest { + if m == nil { + return (*ReleaseRequest)(nil) + } + r := &ReleaseRequest{ + EffectiveCallerId: m.EffectiveCallerId.CloneVT(), + ImmediateCallerId: m.ImmediateCallerId.CloneVT(), + Target: m.Target.CloneVT(), + TransactionId: m.TransactionId, + ReservedId: m.ReservedId, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReleaseRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReleaseResponse) CloneVT() *ReleaseResponse { + if m == nil { + return (*ReleaseResponse)(nil) + } + r := &ReleaseResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReleaseResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StreamHealthRequest) CloneVT() *StreamHealthRequest { + if m == nil { + return (*StreamHealthRequest)(nil) + } + r := &StreamHealthRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StreamHealthRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RealtimeStats) CloneVT() *RealtimeStats { + if m == nil { + return (*RealtimeStats)(nil) + } + r := &RealtimeStats{ + HealthError: m.HealthError, + ReplicationLagSeconds: m.ReplicationLagSeconds, + BinlogPlayersCount: m.BinlogPlayersCount, + FilteredReplicationLagSeconds: m.FilteredReplicationLagSeconds, + CpuUsage: m.CpuUsage, + Qps: m.Qps, + } + if rhs := m.TableSchemaChanged; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.TableSchemaChanged = tmpContainer + } + if rhs := m.ViewSchemaChanged; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ViewSchemaChanged = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RealtimeStats) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *AggregateStats) CloneVT() *AggregateStats { + if m == nil { + return (*AggregateStats)(nil) + } + r := &AggregateStats{ + HealthyTabletCount: m.HealthyTabletCount, + UnhealthyTabletCount: m.UnhealthyTabletCount, + ReplicationLagSecondsMin: m.ReplicationLagSecondsMin, + ReplicationLagSecondsMax: m.ReplicationLagSecondsMax, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *AggregateStats) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StreamHealthResponse) CloneVT() *StreamHealthResponse { + if m == nil { + return (*StreamHealthResponse)(nil) + } + r := &StreamHealthResponse{ + Target: m.Target.CloneVT(), + Serving: m.Serving, + PrimaryTermStartTimestamp: m.PrimaryTermStartTimestamp, + RealtimeStats: m.RealtimeStats.CloneVT(), + TabletAlias: m.TabletAlias.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StreamHealthResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *TransactionMetadata) CloneVT() *TransactionMetadata { + if m == nil { + return (*TransactionMetadata)(nil) + } + r := &TransactionMetadata{ + Dtid: m.Dtid, + State: m.State, + TimeCreated: m.TimeCreated, + } + if rhs := m.Participants; rhs != nil { + tmpContainer := make([]*Target, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Participants = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *TransactionMetadata) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSchemaRequest) CloneVT() *GetSchemaRequest { + if m == nil { + return (*GetSchemaRequest)(nil) + } + r := &GetSchemaRequest{ + Target: m.Target.CloneVT(), + TableType: m.TableType, + } + if rhs := m.TableNames; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.TableNames = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSchemaRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSchemaResponse) CloneVT() *GetSchemaResponse { + if m == nil { + return (*GetSchemaResponse)(nil) + } + r := &GetSchemaResponse{} + if rhs := m.TableDefinition; rhs != nil { + tmpContainer := make(map[string]string, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.TableDefinition = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSchemaResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + func (m *Target) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil diff --git a/go/vt/proto/replicationdata/replicationdata_vtproto.pb.go b/go/vt/proto/replicationdata/replicationdata_vtproto.pb.go index 64e5a8d8b94..f92a42b05e4 100644 --- a/go/vt/proto/replicationdata/replicationdata_vtproto.pb.go +++ b/go/vt/proto/replicationdata/replicationdata_vtproto.pb.go @@ -1,11 +1,12 @@ // Code generated by protoc-gen-go-vtproto. DO NOT EDIT. -// protoc-gen-go-vtproto version: v0.4.0 +// protoc-gen-go-vtproto version: v0.5.0 // source: replicationdata.proto package replicationdata import ( fmt "fmt" + proto "google.golang.org/protobuf/proto" protoimpl "google.golang.org/protobuf/runtime/protoimpl" io "io" bits "math/bits" @@ -18,6 +19,121 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +func (m *Status) CloneVT() *Status { + if m == nil { + return (*Status)(nil) + } + r := &Status{ + Position: m.Position, + ReplicationLagSeconds: m.ReplicationLagSeconds, + SourceHost: m.SourceHost, + SourcePort: m.SourcePort, + ConnectRetry: m.ConnectRetry, + RelayLogPosition: m.RelayLogPosition, + FilePosition: m.FilePosition, + RelayLogSourceBinlogEquivalentPosition: m.RelayLogSourceBinlogEquivalentPosition, + SourceServerId: m.SourceServerId, + SourceUuid: m.SourceUuid, + IoState: m.IoState, + LastIoError: m.LastIoError, + SqlState: m.SqlState, + LastSqlError: m.LastSqlError, + RelayLogFilePosition: m.RelayLogFilePosition, + SourceUser: m.SourceUser, + SqlDelay: m.SqlDelay, + AutoPosition: m.AutoPosition, + UsingGtid: m.UsingGtid, + HasReplicationFilters: m.HasReplicationFilters, + SslAllowed: m.SslAllowed, + ReplicationLagUnknown: m.ReplicationLagUnknown, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Status) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StopReplicationStatus) CloneVT() *StopReplicationStatus { + if m == nil { + return (*StopReplicationStatus)(nil) + } + r := &StopReplicationStatus{ + Before: m.Before.CloneVT(), + After: m.After.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StopReplicationStatus) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PrimaryStatus) CloneVT() *PrimaryStatus { + if m == nil { + return (*PrimaryStatus)(nil) + } + r := &PrimaryStatus{ + Position: m.Position, + FilePosition: m.FilePosition, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PrimaryStatus) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *FullStatus) CloneVT() *FullStatus { + if m == nil { + return (*FullStatus)(nil) + } + r := &FullStatus{ + ServerId: m.ServerId, + ServerUuid: m.ServerUuid, + ReplicationStatus: m.ReplicationStatus.CloneVT(), + PrimaryStatus: m.PrimaryStatus.CloneVT(), + GtidPurged: m.GtidPurged, + Version: m.Version, + VersionComment: m.VersionComment, + ReadOnly: m.ReadOnly, + GtidMode: m.GtidMode, + BinlogFormat: m.BinlogFormat, + BinlogRowImage: m.BinlogRowImage, + LogBinEnabled: m.LogBinEnabled, + LogReplicaUpdates: m.LogReplicaUpdates, + SemiSyncPrimaryEnabled: m.SemiSyncPrimaryEnabled, + SemiSyncReplicaEnabled: m.SemiSyncReplicaEnabled, + SemiSyncPrimaryStatus: m.SemiSyncPrimaryStatus, + SemiSyncReplicaStatus: m.SemiSyncReplicaStatus, + SemiSyncPrimaryClients: m.SemiSyncPrimaryClients, + SemiSyncPrimaryTimeout: m.SemiSyncPrimaryTimeout, + SemiSyncWaitForReplicaCount: m.SemiSyncWaitForReplicaCount, + SuperReadOnly: m.SuperReadOnly, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *FullStatus) CloneMessageVT() proto.Message { + return m.CloneVT() +} + func (m *Status) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil diff --git a/go/vt/proto/tableacl/tableacl_vtproto.pb.go b/go/vt/proto/tableacl/tableacl_vtproto.pb.go index 462bf151230..8c9c9a97856 100644 --- a/go/vt/proto/tableacl/tableacl_vtproto.pb.go +++ b/go/vt/proto/tableacl/tableacl_vtproto.pb.go @@ -1,11 +1,12 @@ // Code generated by protoc-gen-go-vtproto. DO NOT EDIT. -// protoc-gen-go-vtproto version: v0.4.0 +// protoc-gen-go-vtproto version: v0.5.0 // source: tableacl.proto package tableacl import ( fmt "fmt" + proto "google.golang.org/protobuf/proto" protoimpl "google.golang.org/protobuf/runtime/protoimpl" io "io" bits "math/bits" @@ -18,6 +19,67 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +func (m *TableGroupSpec) CloneVT() *TableGroupSpec { + if m == nil { + return (*TableGroupSpec)(nil) + } + r := &TableGroupSpec{ + Name: m.Name, + } + if rhs := m.TableNamesOrPrefixes; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.TableNamesOrPrefixes = tmpContainer + } + if rhs := m.Readers; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Readers = tmpContainer + } + if rhs := m.Writers; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Writers = tmpContainer + } + if rhs := m.Admins; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Admins = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *TableGroupSpec) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Config) CloneVT() *Config { + if m == nil { + return (*Config)(nil) + } + r := &Config{} + if rhs := m.TableGroups; rhs != nil { + tmpContainer := make([]*TableGroupSpec, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.TableGroups = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Config) CloneMessageVT() proto.Message { + return m.CloneVT() +} + func (m *TableGroupSpec) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil diff --git a/go/vt/proto/tabletmanagerdata/tabletmanagerdata_vtproto.pb.go b/go/vt/proto/tabletmanagerdata/tabletmanagerdata_vtproto.pb.go index bf748cec8c5..502a4c17ff9 100644 --- a/go/vt/proto/tabletmanagerdata/tabletmanagerdata_vtproto.pb.go +++ b/go/vt/proto/tabletmanagerdata/tabletmanagerdata_vtproto.pb.go @@ -1,5 +1,5 @@ // Code generated by protoc-gen-go-vtproto. DO NOT EDIT. -// protoc-gen-go-vtproto version: v0.4.0 +// protoc-gen-go-vtproto version: v0.5.0 // source: tabletmanagerdata.proto package tabletmanagerdata @@ -7,6 +7,7 @@ package tabletmanagerdata import ( binary "encoding/binary" fmt "fmt" + proto "google.golang.org/protobuf/proto" protoimpl "google.golang.org/protobuf/runtime/protoimpl" io "io" math "math" @@ -27,6 +28,2241 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +func (m *TableDefinition) CloneVT() *TableDefinition { + if m == nil { + return (*TableDefinition)(nil) + } + r := &TableDefinition{ + Name: m.Name, + Schema: m.Schema, + Type: m.Type, + DataLength: m.DataLength, + RowCount: m.RowCount, + } + if rhs := m.Columns; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Columns = tmpContainer + } + if rhs := m.PrimaryKeyColumns; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.PrimaryKeyColumns = tmpContainer + } + if rhs := m.Fields; rhs != nil { + tmpContainer := make([]*query.Field, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Fields = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *TableDefinition) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SchemaDefinition) CloneVT() *SchemaDefinition { + if m == nil { + return (*SchemaDefinition)(nil) + } + r := &SchemaDefinition{ + DatabaseSchema: m.DatabaseSchema, + } + if rhs := m.TableDefinitions; rhs != nil { + tmpContainer := make([]*TableDefinition, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.TableDefinitions = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SchemaDefinition) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SchemaChangeResult) CloneVT() *SchemaChangeResult { + if m == nil { + return (*SchemaChangeResult)(nil) + } + r := &SchemaChangeResult{ + BeforeSchema: m.BeforeSchema.CloneVT(), + AfterSchema: m.AfterSchema.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SchemaChangeResult) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UserPermission) CloneVT() *UserPermission { + if m == nil { + return (*UserPermission)(nil) + } + r := &UserPermission{ + Host: m.Host, + User: m.User, + PasswordChecksum: m.PasswordChecksum, + } + if rhs := m.Privileges; rhs != nil { + tmpContainer := make(map[string]string, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.Privileges = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UserPermission) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DbPermission) CloneVT() *DbPermission { + if m == nil { + return (*DbPermission)(nil) + } + r := &DbPermission{ + Host: m.Host, + Db: m.Db, + User: m.User, + } + if rhs := m.Privileges; rhs != nil { + tmpContainer := make(map[string]string, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.Privileges = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DbPermission) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Permissions) CloneVT() *Permissions { + if m == nil { + return (*Permissions)(nil) + } + r := &Permissions{} + if rhs := m.UserPermissions; rhs != nil { + tmpContainer := make([]*UserPermission, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.UserPermissions = tmpContainer + } + if rhs := m.DbPermissions; rhs != nil { + tmpContainer := make([]*DbPermission, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.DbPermissions = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Permissions) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PingRequest) CloneVT() *PingRequest { + if m == nil { + return (*PingRequest)(nil) + } + r := &PingRequest{ + Payload: m.Payload, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PingRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PingResponse) CloneVT() *PingResponse { + if m == nil { + return (*PingResponse)(nil) + } + r := &PingResponse{ + Payload: m.Payload, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PingResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SleepRequest) CloneVT() *SleepRequest { + if m == nil { + return (*SleepRequest)(nil) + } + r := &SleepRequest{ + Duration: m.Duration, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SleepRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SleepResponse) CloneVT() *SleepResponse { + if m == nil { + return (*SleepResponse)(nil) + } + r := &SleepResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SleepResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteHookRequest) CloneVT() *ExecuteHookRequest { + if m == nil { + return (*ExecuteHookRequest)(nil) + } + r := &ExecuteHookRequest{ + Name: m.Name, + } + if rhs := m.Parameters; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Parameters = tmpContainer + } + if rhs := m.ExtraEnv; rhs != nil { + tmpContainer := make(map[string]string, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.ExtraEnv = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteHookRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteHookResponse) CloneVT() *ExecuteHookResponse { + if m == nil { + return (*ExecuteHookResponse)(nil) + } + r := &ExecuteHookResponse{ + ExitStatus: m.ExitStatus, + Stdout: m.Stdout, + Stderr: m.Stderr, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteHookResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSchemaRequest) CloneVT() *GetSchemaRequest { + if m == nil { + return (*GetSchemaRequest)(nil) + } + r := &GetSchemaRequest{ + IncludeViews: m.IncludeViews, + TableSchemaOnly: m.TableSchemaOnly, + } + if rhs := m.Tables; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Tables = tmpContainer + } + if rhs := m.ExcludeTables; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ExcludeTables = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSchemaRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSchemaResponse) CloneVT() *GetSchemaResponse { + if m == nil { + return (*GetSchemaResponse)(nil) + } + r := &GetSchemaResponse{ + SchemaDefinition: m.SchemaDefinition.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSchemaResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetPermissionsRequest) CloneVT() *GetPermissionsRequest { + if m == nil { + return (*GetPermissionsRequest)(nil) + } + r := &GetPermissionsRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetPermissionsRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetPermissionsResponse) CloneVT() *GetPermissionsResponse { + if m == nil { + return (*GetPermissionsResponse)(nil) + } + r := &GetPermissionsResponse{ + Permissions: m.Permissions.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetPermissionsResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetReadOnlyRequest) CloneVT() *SetReadOnlyRequest { + if m == nil { + return (*SetReadOnlyRequest)(nil) + } + r := &SetReadOnlyRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetReadOnlyRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetReadOnlyResponse) CloneVT() *SetReadOnlyResponse { + if m == nil { + return (*SetReadOnlyResponse)(nil) + } + r := &SetReadOnlyResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetReadOnlyResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetReadWriteRequest) CloneVT() *SetReadWriteRequest { + if m == nil { + return (*SetReadWriteRequest)(nil) + } + r := &SetReadWriteRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetReadWriteRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetReadWriteResponse) CloneVT() *SetReadWriteResponse { + if m == nil { + return (*SetReadWriteResponse)(nil) + } + r := &SetReadWriteResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetReadWriteResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ChangeTypeRequest) CloneVT() *ChangeTypeRequest { + if m == nil { + return (*ChangeTypeRequest)(nil) + } + r := &ChangeTypeRequest{ + TabletType: m.TabletType, + SemiSync: m.SemiSync, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ChangeTypeRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ChangeTypeResponse) CloneVT() *ChangeTypeResponse { + if m == nil { + return (*ChangeTypeResponse)(nil) + } + r := &ChangeTypeResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ChangeTypeResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RefreshStateRequest) CloneVT() *RefreshStateRequest { + if m == nil { + return (*RefreshStateRequest)(nil) + } + r := &RefreshStateRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RefreshStateRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RefreshStateResponse) CloneVT() *RefreshStateResponse { + if m == nil { + return (*RefreshStateResponse)(nil) + } + r := &RefreshStateResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RefreshStateResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RunHealthCheckRequest) CloneVT() *RunHealthCheckRequest { + if m == nil { + return (*RunHealthCheckRequest)(nil) + } + r := &RunHealthCheckRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RunHealthCheckRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RunHealthCheckResponse) CloneVT() *RunHealthCheckResponse { + if m == nil { + return (*RunHealthCheckResponse)(nil) + } + r := &RunHealthCheckResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RunHealthCheckResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReloadSchemaRequest) CloneVT() *ReloadSchemaRequest { + if m == nil { + return (*ReloadSchemaRequest)(nil) + } + r := &ReloadSchemaRequest{ + WaitPosition: m.WaitPosition, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReloadSchemaRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReloadSchemaResponse) CloneVT() *ReloadSchemaResponse { + if m == nil { + return (*ReloadSchemaResponse)(nil) + } + r := &ReloadSchemaResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReloadSchemaResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PreflightSchemaRequest) CloneVT() *PreflightSchemaRequest { + if m == nil { + return (*PreflightSchemaRequest)(nil) + } + r := &PreflightSchemaRequest{} + if rhs := m.Changes; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Changes = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PreflightSchemaRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PreflightSchemaResponse) CloneVT() *PreflightSchemaResponse { + if m == nil { + return (*PreflightSchemaResponse)(nil) + } + r := &PreflightSchemaResponse{} + if rhs := m.ChangeResults; rhs != nil { + tmpContainer := make([]*SchemaChangeResult, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ChangeResults = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PreflightSchemaResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ApplySchemaRequest) CloneVT() *ApplySchemaRequest { + if m == nil { + return (*ApplySchemaRequest)(nil) + } + r := &ApplySchemaRequest{ + Sql: m.Sql, + Force: m.Force, + AllowReplication: m.AllowReplication, + BeforeSchema: m.BeforeSchema.CloneVT(), + AfterSchema: m.AfterSchema.CloneVT(), + SqlMode: m.SqlMode, + BatchSize: m.BatchSize, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ApplySchemaRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ApplySchemaResponse) CloneVT() *ApplySchemaResponse { + if m == nil { + return (*ApplySchemaResponse)(nil) + } + r := &ApplySchemaResponse{ + BeforeSchema: m.BeforeSchema.CloneVT(), + AfterSchema: m.AfterSchema.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ApplySchemaResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *LockTablesRequest) CloneVT() *LockTablesRequest { + if m == nil { + return (*LockTablesRequest)(nil) + } + r := &LockTablesRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *LockTablesRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *LockTablesResponse) CloneVT() *LockTablesResponse { + if m == nil { + return (*LockTablesResponse)(nil) + } + r := &LockTablesResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *LockTablesResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UnlockTablesRequest) CloneVT() *UnlockTablesRequest { + if m == nil { + return (*UnlockTablesRequest)(nil) + } + r := &UnlockTablesRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UnlockTablesRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UnlockTablesResponse) CloneVT() *UnlockTablesResponse { + if m == nil { + return (*UnlockTablesResponse)(nil) + } + r := &UnlockTablesResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UnlockTablesResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteQueryRequest) CloneVT() *ExecuteQueryRequest { + if m == nil { + return (*ExecuteQueryRequest)(nil) + } + r := &ExecuteQueryRequest{ + DbName: m.DbName, + MaxRows: m.MaxRows, + CallerId: m.CallerId.CloneVT(), + } + if rhs := m.Query; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.Query = tmpBytes + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteQueryRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteQueryResponse) CloneVT() *ExecuteQueryResponse { + if m == nil { + return (*ExecuteQueryResponse)(nil) + } + r := &ExecuteQueryResponse{ + Result: m.Result.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteQueryResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteFetchAsDbaRequest) CloneVT() *ExecuteFetchAsDbaRequest { + if m == nil { + return (*ExecuteFetchAsDbaRequest)(nil) + } + r := &ExecuteFetchAsDbaRequest{ + DbName: m.DbName, + MaxRows: m.MaxRows, + DisableBinlogs: m.DisableBinlogs, + ReloadSchema: m.ReloadSchema, + } + if rhs := m.Query; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.Query = tmpBytes + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteFetchAsDbaRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteFetchAsDbaResponse) CloneVT() *ExecuteFetchAsDbaResponse { + if m == nil { + return (*ExecuteFetchAsDbaResponse)(nil) + } + r := &ExecuteFetchAsDbaResponse{ + Result: m.Result.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteFetchAsDbaResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteFetchAsAllPrivsRequest) CloneVT() *ExecuteFetchAsAllPrivsRequest { + if m == nil { + return (*ExecuteFetchAsAllPrivsRequest)(nil) + } + r := &ExecuteFetchAsAllPrivsRequest{ + DbName: m.DbName, + MaxRows: m.MaxRows, + ReloadSchema: m.ReloadSchema, + } + if rhs := m.Query; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.Query = tmpBytes + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteFetchAsAllPrivsRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteFetchAsAllPrivsResponse) CloneVT() *ExecuteFetchAsAllPrivsResponse { + if m == nil { + return (*ExecuteFetchAsAllPrivsResponse)(nil) + } + r := &ExecuteFetchAsAllPrivsResponse{ + Result: m.Result.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteFetchAsAllPrivsResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteFetchAsAppRequest) CloneVT() *ExecuteFetchAsAppRequest { + if m == nil { + return (*ExecuteFetchAsAppRequest)(nil) + } + r := &ExecuteFetchAsAppRequest{ + MaxRows: m.MaxRows, + } + if rhs := m.Query; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.Query = tmpBytes + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteFetchAsAppRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteFetchAsAppResponse) CloneVT() *ExecuteFetchAsAppResponse { + if m == nil { + return (*ExecuteFetchAsAppResponse)(nil) + } + r := &ExecuteFetchAsAppResponse{ + Result: m.Result.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteFetchAsAppResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReplicationStatusRequest) CloneVT() *ReplicationStatusRequest { + if m == nil { + return (*ReplicationStatusRequest)(nil) + } + r := &ReplicationStatusRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReplicationStatusRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReplicationStatusResponse) CloneVT() *ReplicationStatusResponse { + if m == nil { + return (*ReplicationStatusResponse)(nil) + } + r := &ReplicationStatusResponse{ + Status: m.Status.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReplicationStatusResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PrimaryStatusRequest) CloneVT() *PrimaryStatusRequest { + if m == nil { + return (*PrimaryStatusRequest)(nil) + } + r := &PrimaryStatusRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PrimaryStatusRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PrimaryStatusResponse) CloneVT() *PrimaryStatusResponse { + if m == nil { + return (*PrimaryStatusResponse)(nil) + } + r := &PrimaryStatusResponse{ + Status: m.Status.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PrimaryStatusResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PrimaryPositionRequest) CloneVT() *PrimaryPositionRequest { + if m == nil { + return (*PrimaryPositionRequest)(nil) + } + r := &PrimaryPositionRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PrimaryPositionRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PrimaryPositionResponse) CloneVT() *PrimaryPositionResponse { + if m == nil { + return (*PrimaryPositionResponse)(nil) + } + r := &PrimaryPositionResponse{ + Position: m.Position, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PrimaryPositionResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *WaitForPositionRequest) CloneVT() *WaitForPositionRequest { + if m == nil { + return (*WaitForPositionRequest)(nil) + } + r := &WaitForPositionRequest{ + Position: m.Position, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *WaitForPositionRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *WaitForPositionResponse) CloneVT() *WaitForPositionResponse { + if m == nil { + return (*WaitForPositionResponse)(nil) + } + r := &WaitForPositionResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *WaitForPositionResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StopReplicationRequest) CloneVT() *StopReplicationRequest { + if m == nil { + return (*StopReplicationRequest)(nil) + } + r := &StopReplicationRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StopReplicationRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StopReplicationResponse) CloneVT() *StopReplicationResponse { + if m == nil { + return (*StopReplicationResponse)(nil) + } + r := &StopReplicationResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StopReplicationResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StopReplicationMinimumRequest) CloneVT() *StopReplicationMinimumRequest { + if m == nil { + return (*StopReplicationMinimumRequest)(nil) + } + r := &StopReplicationMinimumRequest{ + Position: m.Position, + WaitTimeout: m.WaitTimeout, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StopReplicationMinimumRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StopReplicationMinimumResponse) CloneVT() *StopReplicationMinimumResponse { + if m == nil { + return (*StopReplicationMinimumResponse)(nil) + } + r := &StopReplicationMinimumResponse{ + Position: m.Position, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StopReplicationMinimumResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StartReplicationRequest) CloneVT() *StartReplicationRequest { + if m == nil { + return (*StartReplicationRequest)(nil) + } + r := &StartReplicationRequest{ + SemiSync: m.SemiSync, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StartReplicationRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StartReplicationResponse) CloneVT() *StartReplicationResponse { + if m == nil { + return (*StartReplicationResponse)(nil) + } + r := &StartReplicationResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StartReplicationResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StartReplicationUntilAfterRequest) CloneVT() *StartReplicationUntilAfterRequest { + if m == nil { + return (*StartReplicationUntilAfterRequest)(nil) + } + r := &StartReplicationUntilAfterRequest{ + Position: m.Position, + WaitTimeout: m.WaitTimeout, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StartReplicationUntilAfterRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StartReplicationUntilAfterResponse) CloneVT() *StartReplicationUntilAfterResponse { + if m == nil { + return (*StartReplicationUntilAfterResponse)(nil) + } + r := &StartReplicationUntilAfterResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StartReplicationUntilAfterResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetReplicasRequest) CloneVT() *GetReplicasRequest { + if m == nil { + return (*GetReplicasRequest)(nil) + } + r := &GetReplicasRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetReplicasRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetReplicasResponse) CloneVT() *GetReplicasResponse { + if m == nil { + return (*GetReplicasResponse)(nil) + } + r := &GetReplicasResponse{} + if rhs := m.Addrs; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Addrs = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetReplicasResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ResetReplicationRequest) CloneVT() *ResetReplicationRequest { + if m == nil { + return (*ResetReplicationRequest)(nil) + } + r := &ResetReplicationRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ResetReplicationRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ResetReplicationResponse) CloneVT() *ResetReplicationResponse { + if m == nil { + return (*ResetReplicationResponse)(nil) + } + r := &ResetReplicationResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ResetReplicationResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VReplicationExecRequest) CloneVT() *VReplicationExecRequest { + if m == nil { + return (*VReplicationExecRequest)(nil) + } + r := &VReplicationExecRequest{ + Query: m.Query, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VReplicationExecRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VReplicationExecResponse) CloneVT() *VReplicationExecResponse { + if m == nil { + return (*VReplicationExecResponse)(nil) + } + r := &VReplicationExecResponse{ + Result: m.Result.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VReplicationExecResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VReplicationWaitForPosRequest) CloneVT() *VReplicationWaitForPosRequest { + if m == nil { + return (*VReplicationWaitForPosRequest)(nil) + } + r := &VReplicationWaitForPosRequest{ + Id: m.Id, + Position: m.Position, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VReplicationWaitForPosRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VReplicationWaitForPosResponse) CloneVT() *VReplicationWaitForPosResponse { + if m == nil { + return (*VReplicationWaitForPosResponse)(nil) + } + r := &VReplicationWaitForPosResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VReplicationWaitForPosResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *InitPrimaryRequest) CloneVT() *InitPrimaryRequest { + if m == nil { + return (*InitPrimaryRequest)(nil) + } + r := &InitPrimaryRequest{ + SemiSync: m.SemiSync, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *InitPrimaryRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *InitPrimaryResponse) CloneVT() *InitPrimaryResponse { + if m == nil { + return (*InitPrimaryResponse)(nil) + } + r := &InitPrimaryResponse{ + Position: m.Position, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *InitPrimaryResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PopulateReparentJournalRequest) CloneVT() *PopulateReparentJournalRequest { + if m == nil { + return (*PopulateReparentJournalRequest)(nil) + } + r := &PopulateReparentJournalRequest{ + TimeCreatedNs: m.TimeCreatedNs, + ActionName: m.ActionName, + PrimaryAlias: m.PrimaryAlias.CloneVT(), + ReplicationPosition: m.ReplicationPosition, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PopulateReparentJournalRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PopulateReparentJournalResponse) CloneVT() *PopulateReparentJournalResponse { + if m == nil { + return (*PopulateReparentJournalResponse)(nil) + } + r := &PopulateReparentJournalResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PopulateReparentJournalResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *InitReplicaRequest) CloneVT() *InitReplicaRequest { + if m == nil { + return (*InitReplicaRequest)(nil) + } + r := &InitReplicaRequest{ + Parent: m.Parent.CloneVT(), + ReplicationPosition: m.ReplicationPosition, + TimeCreatedNs: m.TimeCreatedNs, + SemiSync: m.SemiSync, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *InitReplicaRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *InitReplicaResponse) CloneVT() *InitReplicaResponse { + if m == nil { + return (*InitReplicaResponse)(nil) + } + r := &InitReplicaResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *InitReplicaResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DemotePrimaryRequest) CloneVT() *DemotePrimaryRequest { + if m == nil { + return (*DemotePrimaryRequest)(nil) + } + r := &DemotePrimaryRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DemotePrimaryRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DemotePrimaryResponse) CloneVT() *DemotePrimaryResponse { + if m == nil { + return (*DemotePrimaryResponse)(nil) + } + r := &DemotePrimaryResponse{ + PrimaryStatus: m.PrimaryStatus.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DemotePrimaryResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UndoDemotePrimaryRequest) CloneVT() *UndoDemotePrimaryRequest { + if m == nil { + return (*UndoDemotePrimaryRequest)(nil) + } + r := &UndoDemotePrimaryRequest{ + SemiSync: m.SemiSync, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UndoDemotePrimaryRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UndoDemotePrimaryResponse) CloneVT() *UndoDemotePrimaryResponse { + if m == nil { + return (*UndoDemotePrimaryResponse)(nil) + } + r := &UndoDemotePrimaryResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UndoDemotePrimaryResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReplicaWasPromotedRequest) CloneVT() *ReplicaWasPromotedRequest { + if m == nil { + return (*ReplicaWasPromotedRequest)(nil) + } + r := &ReplicaWasPromotedRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReplicaWasPromotedRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReplicaWasPromotedResponse) CloneVT() *ReplicaWasPromotedResponse { + if m == nil { + return (*ReplicaWasPromotedResponse)(nil) + } + r := &ReplicaWasPromotedResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReplicaWasPromotedResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ResetReplicationParametersRequest) CloneVT() *ResetReplicationParametersRequest { + if m == nil { + return (*ResetReplicationParametersRequest)(nil) + } + r := &ResetReplicationParametersRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ResetReplicationParametersRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ResetReplicationParametersResponse) CloneVT() *ResetReplicationParametersResponse { + if m == nil { + return (*ResetReplicationParametersResponse)(nil) + } + r := &ResetReplicationParametersResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ResetReplicationParametersResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *FullStatusRequest) CloneVT() *FullStatusRequest { + if m == nil { + return (*FullStatusRequest)(nil) + } + r := &FullStatusRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *FullStatusRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *FullStatusResponse) CloneVT() *FullStatusResponse { + if m == nil { + return (*FullStatusResponse)(nil) + } + r := &FullStatusResponse{ + Status: m.Status.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *FullStatusResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetReplicationSourceRequest) CloneVT() *SetReplicationSourceRequest { + if m == nil { + return (*SetReplicationSourceRequest)(nil) + } + r := &SetReplicationSourceRequest{ + Parent: m.Parent.CloneVT(), + TimeCreatedNs: m.TimeCreatedNs, + ForceStartReplication: m.ForceStartReplication, + WaitPosition: m.WaitPosition, + SemiSync: m.SemiSync, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetReplicationSourceRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetReplicationSourceResponse) CloneVT() *SetReplicationSourceResponse { + if m == nil { + return (*SetReplicationSourceResponse)(nil) + } + r := &SetReplicationSourceResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetReplicationSourceResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReplicaWasRestartedRequest) CloneVT() *ReplicaWasRestartedRequest { + if m == nil { + return (*ReplicaWasRestartedRequest)(nil) + } + r := &ReplicaWasRestartedRequest{ + Parent: m.Parent.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReplicaWasRestartedRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReplicaWasRestartedResponse) CloneVT() *ReplicaWasRestartedResponse { + if m == nil { + return (*ReplicaWasRestartedResponse)(nil) + } + r := &ReplicaWasRestartedResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReplicaWasRestartedResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StopReplicationAndGetStatusRequest) CloneVT() *StopReplicationAndGetStatusRequest { + if m == nil { + return (*StopReplicationAndGetStatusRequest)(nil) + } + r := &StopReplicationAndGetStatusRequest{ + StopReplicationMode: m.StopReplicationMode, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StopReplicationAndGetStatusRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StopReplicationAndGetStatusResponse) CloneVT() *StopReplicationAndGetStatusResponse { + if m == nil { + return (*StopReplicationAndGetStatusResponse)(nil) + } + r := &StopReplicationAndGetStatusResponse{ + Status: m.Status.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StopReplicationAndGetStatusResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PromoteReplicaRequest) CloneVT() *PromoteReplicaRequest { + if m == nil { + return (*PromoteReplicaRequest)(nil) + } + r := &PromoteReplicaRequest{ + SemiSync: m.SemiSync, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PromoteReplicaRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PromoteReplicaResponse) CloneVT() *PromoteReplicaResponse { + if m == nil { + return (*PromoteReplicaResponse)(nil) + } + r := &PromoteReplicaResponse{ + Position: m.Position, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PromoteReplicaResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *BackupRequest) CloneVT() *BackupRequest { + if m == nil { + return (*BackupRequest)(nil) + } + r := &BackupRequest{ + Concurrency: m.Concurrency, + AllowPrimary: m.AllowPrimary, + IncrementalFromPos: m.IncrementalFromPos, + UpgradeSafe: m.UpgradeSafe, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BackupRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *BackupResponse) CloneVT() *BackupResponse { + if m == nil { + return (*BackupResponse)(nil) + } + r := &BackupResponse{ + Event: m.Event.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BackupResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RestoreFromBackupRequest) CloneVT() *RestoreFromBackupRequest { + if m == nil { + return (*RestoreFromBackupRequest)(nil) + } + r := &RestoreFromBackupRequest{ + BackupTime: m.BackupTime.CloneVT(), + RestoreToPos: m.RestoreToPos, + DryRun: m.DryRun, + RestoreToTimestamp: m.RestoreToTimestamp.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RestoreFromBackupRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RestoreFromBackupResponse) CloneVT() *RestoreFromBackupResponse { + if m == nil { + return (*RestoreFromBackupResponse)(nil) + } + r := &RestoreFromBackupResponse{ + Event: m.Event.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RestoreFromBackupResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CreateVReplicationWorkflowRequest) CloneVT() *CreateVReplicationWorkflowRequest { + if m == nil { + return (*CreateVReplicationWorkflowRequest)(nil) + } + r := &CreateVReplicationWorkflowRequest{ + Workflow: m.Workflow, + TabletSelectionPreference: m.TabletSelectionPreference, + WorkflowType: m.WorkflowType, + WorkflowSubType: m.WorkflowSubType, + DeferSecondaryKeys: m.DeferSecondaryKeys, + AutoStart: m.AutoStart, + StopAfterCopy: m.StopAfterCopy, + } + if rhs := m.BinlogSource; rhs != nil { + tmpContainer := make([]*binlogdata.BinlogSource, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.BinlogSource = tmpContainer + } + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if rhs := m.TabletTypes; rhs != nil { + tmpContainer := make([]topodata.TabletType, len(rhs)) + copy(tmpContainer, rhs) + r.TabletTypes = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CreateVReplicationWorkflowRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CreateVReplicationWorkflowResponse) CloneVT() *CreateVReplicationWorkflowResponse { + if m == nil { + return (*CreateVReplicationWorkflowResponse)(nil) + } + r := &CreateVReplicationWorkflowResponse{ + Result: m.Result.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CreateVReplicationWorkflowResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DeleteVReplicationWorkflowRequest) CloneVT() *DeleteVReplicationWorkflowRequest { + if m == nil { + return (*DeleteVReplicationWorkflowRequest)(nil) + } + r := &DeleteVReplicationWorkflowRequest{ + Workflow: m.Workflow, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DeleteVReplicationWorkflowRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DeleteVReplicationWorkflowResponse) CloneVT() *DeleteVReplicationWorkflowResponse { + if m == nil { + return (*DeleteVReplicationWorkflowResponse)(nil) + } + r := &DeleteVReplicationWorkflowResponse{ + Result: m.Result.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DeleteVReplicationWorkflowResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReadVReplicationWorkflowRequest) CloneVT() *ReadVReplicationWorkflowRequest { + if m == nil { + return (*ReadVReplicationWorkflowRequest)(nil) + } + r := &ReadVReplicationWorkflowRequest{ + Workflow: m.Workflow, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReadVReplicationWorkflowRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReadVReplicationWorkflowResponse_Stream) CloneVT() *ReadVReplicationWorkflowResponse_Stream { + if m == nil { + return (*ReadVReplicationWorkflowResponse_Stream)(nil) + } + r := &ReadVReplicationWorkflowResponse_Stream{ + Id: m.Id, + Bls: m.Bls.CloneVT(), + Pos: m.Pos, + StopPos: m.StopPos, + MaxTps: m.MaxTps, + MaxReplicationLag: m.MaxReplicationLag, + TimeUpdated: m.TimeUpdated.CloneVT(), + TransactionTimestamp: m.TransactionTimestamp.CloneVT(), + State: m.State, + Message: m.Message, + RowsCopied: m.RowsCopied, + TimeHeartbeat: m.TimeHeartbeat.CloneVT(), + TimeThrottled: m.TimeThrottled.CloneVT(), + ComponentThrottled: m.ComponentThrottled, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReadVReplicationWorkflowResponse_Stream) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReadVReplicationWorkflowResponse) CloneVT() *ReadVReplicationWorkflowResponse { + if m == nil { + return (*ReadVReplicationWorkflowResponse)(nil) + } + r := &ReadVReplicationWorkflowResponse{ + Workflow: m.Workflow, + Cells: m.Cells, + TabletSelectionPreference: m.TabletSelectionPreference, + DbName: m.DbName, + Tags: m.Tags, + WorkflowType: m.WorkflowType, + WorkflowSubType: m.WorkflowSubType, + DeferSecondaryKeys: m.DeferSecondaryKeys, + } + if rhs := m.TabletTypes; rhs != nil { + tmpContainer := make([]topodata.TabletType, len(rhs)) + copy(tmpContainer, rhs) + r.TabletTypes = tmpContainer + } + if rhs := m.Streams; rhs != nil { + tmpContainer := make([]*ReadVReplicationWorkflowResponse_Stream, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Streams = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReadVReplicationWorkflowResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VDiffRequest) CloneVT() *VDiffRequest { + if m == nil { + return (*VDiffRequest)(nil) + } + r := &VDiffRequest{ + Keyspace: m.Keyspace, + Workflow: m.Workflow, + Action: m.Action, + ActionArg: m.ActionArg, + VdiffUuid: m.VdiffUuid, + Options: m.Options.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VDiffRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VDiffResponse) CloneVT() *VDiffResponse { + if m == nil { + return (*VDiffResponse)(nil) + } + r := &VDiffResponse{ + Id: m.Id, + Output: m.Output.CloneVT(), + VdiffUuid: m.VdiffUuid, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VDiffResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VDiffPickerOptions) CloneVT() *VDiffPickerOptions { + if m == nil { + return (*VDiffPickerOptions)(nil) + } + r := &VDiffPickerOptions{ + TabletTypes: m.TabletTypes, + SourceCell: m.SourceCell, + TargetCell: m.TargetCell, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VDiffPickerOptions) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VDiffReportOptions) CloneVT() *VDiffReportOptions { + if m == nil { + return (*VDiffReportOptions)(nil) + } + r := &VDiffReportOptions{ + OnlyPks: m.OnlyPks, + DebugQuery: m.DebugQuery, + Format: m.Format, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VDiffReportOptions) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VDiffCoreOptions) CloneVT() *VDiffCoreOptions { + if m == nil { + return (*VDiffCoreOptions)(nil) + } + r := &VDiffCoreOptions{ + Tables: m.Tables, + AutoRetry: m.AutoRetry, + MaxRows: m.MaxRows, + Checksum: m.Checksum, + SamplePct: m.SamplePct, + TimeoutSeconds: m.TimeoutSeconds, + MaxExtraRowsToCompare: m.MaxExtraRowsToCompare, + UpdateTableStats: m.UpdateTableStats, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VDiffCoreOptions) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VDiffOptions) CloneVT() *VDiffOptions { + if m == nil { + return (*VDiffOptions)(nil) + } + r := &VDiffOptions{ + PickerOptions: m.PickerOptions.CloneVT(), + CoreOptions: m.CoreOptions.CloneVT(), + ReportOptions: m.ReportOptions.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VDiffOptions) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UpdateVReplicationWorkflowRequest) CloneVT() *UpdateVReplicationWorkflowRequest { + if m == nil { + return (*UpdateVReplicationWorkflowRequest)(nil) + } + r := &UpdateVReplicationWorkflowRequest{ + Workflow: m.Workflow, + TabletSelectionPreference: m.TabletSelectionPreference, + OnDdl: m.OnDdl, + State: m.State, + } + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if rhs := m.TabletTypes; rhs != nil { + tmpContainer := make([]topodata.TabletType, len(rhs)) + copy(tmpContainer, rhs) + r.TabletTypes = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UpdateVReplicationWorkflowRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UpdateVReplicationWorkflowResponse) CloneVT() *UpdateVReplicationWorkflowResponse { + if m == nil { + return (*UpdateVReplicationWorkflowResponse)(nil) + } + r := &UpdateVReplicationWorkflowResponse{ + Result: m.Result.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UpdateVReplicationWorkflowResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ResetSequencesRequest) CloneVT() *ResetSequencesRequest { + if m == nil { + return (*ResetSequencesRequest)(nil) + } + r := &ResetSequencesRequest{} + if rhs := m.Tables; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Tables = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ResetSequencesRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ResetSequencesResponse) CloneVT() *ResetSequencesResponse { + if m == nil { + return (*ResetSequencesResponse)(nil) + } + r := &ResetSequencesResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ResetSequencesResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CheckThrottlerRequest) CloneVT() *CheckThrottlerRequest { + if m == nil { + return (*CheckThrottlerRequest)(nil) + } + r := &CheckThrottlerRequest{ + AppName: m.AppName, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CheckThrottlerRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CheckThrottlerResponse) CloneVT() *CheckThrottlerResponse { + if m == nil { + return (*CheckThrottlerResponse)(nil) + } + r := &CheckThrottlerResponse{ + StatusCode: m.StatusCode, + Value: m.Value, + Threshold: m.Threshold, + Error: m.Error, + Message: m.Message, + RecentlyChecked: m.RecentlyChecked, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CheckThrottlerResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + func (m *TableDefinition) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil diff --git a/go/vt/proto/throttlerdata/throttlerdata_vtproto.pb.go b/go/vt/proto/throttlerdata/throttlerdata_vtproto.pb.go index 7a061d1fc38..e032b7db8e8 100644 --- a/go/vt/proto/throttlerdata/throttlerdata_vtproto.pb.go +++ b/go/vt/proto/throttlerdata/throttlerdata_vtproto.pb.go @@ -1,5 +1,5 @@ // Code generated by protoc-gen-go-vtproto. DO NOT EDIT. -// protoc-gen-go-vtproto version: v0.4.0 +// protoc-gen-go-vtproto version: v0.5.0 // source: throttlerdata.proto package throttlerdata @@ -7,6 +7,7 @@ package throttlerdata import ( binary "encoding/binary" fmt "fmt" + proto "google.golang.org/protobuf/proto" protoimpl "google.golang.org/protobuf/runtime/protoimpl" io "io" math "math" @@ -20,6 +21,236 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +func (m *MaxRatesRequest) CloneVT() *MaxRatesRequest { + if m == nil { + return (*MaxRatesRequest)(nil) + } + r := &MaxRatesRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *MaxRatesRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *MaxRatesResponse) CloneVT() *MaxRatesResponse { + if m == nil { + return (*MaxRatesResponse)(nil) + } + r := &MaxRatesResponse{} + if rhs := m.Rates; rhs != nil { + tmpContainer := make(map[string]int64, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.Rates = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *MaxRatesResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetMaxRateRequest) CloneVT() *SetMaxRateRequest { + if m == nil { + return (*SetMaxRateRequest)(nil) + } + r := &SetMaxRateRequest{ + Rate: m.Rate, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetMaxRateRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetMaxRateResponse) CloneVT() *SetMaxRateResponse { + if m == nil { + return (*SetMaxRateResponse)(nil) + } + r := &SetMaxRateResponse{} + if rhs := m.Names; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Names = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetMaxRateResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Configuration) CloneVT() *Configuration { + if m == nil { + return (*Configuration)(nil) + } + r := &Configuration{ + TargetReplicationLagSec: m.TargetReplicationLagSec, + MaxReplicationLagSec: m.MaxReplicationLagSec, + InitialRate: m.InitialRate, + MaxIncrease: m.MaxIncrease, + EmergencyDecrease: m.EmergencyDecrease, + MinDurationBetweenIncreasesSec: m.MinDurationBetweenIncreasesSec, + MaxDurationBetweenIncreasesSec: m.MaxDurationBetweenIncreasesSec, + MinDurationBetweenDecreasesSec: m.MinDurationBetweenDecreasesSec, + SpreadBacklogAcrossSec: m.SpreadBacklogAcrossSec, + IgnoreNSlowestReplicas: m.IgnoreNSlowestReplicas, + IgnoreNSlowestRdonlys: m.IgnoreNSlowestRdonlys, + AgeBadRateAfterSec: m.AgeBadRateAfterSec, + BadRateIncrease: m.BadRateIncrease, + MaxRateApproachThreshold: m.MaxRateApproachThreshold, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Configuration) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetConfigurationRequest) CloneVT() *GetConfigurationRequest { + if m == nil { + return (*GetConfigurationRequest)(nil) + } + r := &GetConfigurationRequest{ + ThrottlerName: m.ThrottlerName, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetConfigurationRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetConfigurationResponse) CloneVT() *GetConfigurationResponse { + if m == nil { + return (*GetConfigurationResponse)(nil) + } + r := &GetConfigurationResponse{} + if rhs := m.Configurations; rhs != nil { + tmpContainer := make(map[string]*Configuration, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Configurations = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetConfigurationResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UpdateConfigurationRequest) CloneVT() *UpdateConfigurationRequest { + if m == nil { + return (*UpdateConfigurationRequest)(nil) + } + r := &UpdateConfigurationRequest{ + ThrottlerName: m.ThrottlerName, + Configuration: m.Configuration.CloneVT(), + CopyZeroValues: m.CopyZeroValues, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UpdateConfigurationRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UpdateConfigurationResponse) CloneVT() *UpdateConfigurationResponse { + if m == nil { + return (*UpdateConfigurationResponse)(nil) + } + r := &UpdateConfigurationResponse{} + if rhs := m.Names; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Names = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UpdateConfigurationResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ResetConfigurationRequest) CloneVT() *ResetConfigurationRequest { + if m == nil { + return (*ResetConfigurationRequest)(nil) + } + r := &ResetConfigurationRequest{ + ThrottlerName: m.ThrottlerName, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ResetConfigurationRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ResetConfigurationResponse) CloneVT() *ResetConfigurationResponse { + if m == nil { + return (*ResetConfigurationResponse)(nil) + } + r := &ResetConfigurationResponse{} + if rhs := m.Names; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Names = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ResetConfigurationResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + func (m *MaxRatesRequest) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil diff --git a/go/vt/proto/topodata/topodata_vtproto.pb.go b/go/vt/proto/topodata/topodata_vtproto.pb.go index 5ed87445845..5e675bb4ea0 100644 --- a/go/vt/proto/topodata/topodata_vtproto.pb.go +++ b/go/vt/proto/topodata/topodata_vtproto.pb.go @@ -1,5 +1,5 @@ // Code generated by protoc-gen-go-vtproto. DO NOT EDIT. -// protoc-gen-go-vtproto version: v0.4.0 +// protoc-gen-go-vtproto version: v0.5.0 // source: topodata.proto package topodata @@ -7,6 +7,7 @@ package topodata import ( binary "encoding/binary" fmt "fmt" + proto "google.golang.org/protobuf/proto" protoimpl "google.golang.org/protobuf/runtime/protoimpl" io "io" math "math" @@ -21,6 +22,569 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +func (m *KeyRange) CloneVT() *KeyRange { + if m == nil { + return (*KeyRange)(nil) + } + r := &KeyRange{} + if rhs := m.Start; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.Start = tmpBytes + } + if rhs := m.End; rhs != nil { + tmpBytes := make([]byte, len(rhs)) + copy(tmpBytes, rhs) + r.End = tmpBytes + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *KeyRange) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *TabletAlias) CloneVT() *TabletAlias { + if m == nil { + return (*TabletAlias)(nil) + } + r := &TabletAlias{ + Cell: m.Cell, + Uid: m.Uid, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *TabletAlias) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Tablet) CloneVT() *Tablet { + if m == nil { + return (*Tablet)(nil) + } + r := &Tablet{ + Alias: m.Alias.CloneVT(), + Hostname: m.Hostname, + Keyspace: m.Keyspace, + Shard: m.Shard, + KeyRange: m.KeyRange.CloneVT(), + Type: m.Type, + DbNameOverride: m.DbNameOverride, + MysqlHostname: m.MysqlHostname, + MysqlPort: m.MysqlPort, + PrimaryTermStartTime: m.PrimaryTermStartTime.CloneVT(), + DefaultConnCollation: m.DefaultConnCollation, + } + if rhs := m.PortMap; rhs != nil { + tmpContainer := make(map[string]int32, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.PortMap = tmpContainer + } + if rhs := m.Tags; rhs != nil { + tmpContainer := make(map[string]string, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.Tags = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Tablet) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Shard_SourceShard) CloneVT() *Shard_SourceShard { + if m == nil { + return (*Shard_SourceShard)(nil) + } + r := &Shard_SourceShard{ + Uid: m.Uid, + Keyspace: m.Keyspace, + Shard: m.Shard, + KeyRange: m.KeyRange.CloneVT(), + } + if rhs := m.Tables; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Tables = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Shard_SourceShard) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Shard_TabletControl) CloneVT() *Shard_TabletControl { + if m == nil { + return (*Shard_TabletControl)(nil) + } + r := &Shard_TabletControl{ + TabletType: m.TabletType, + Frozen: m.Frozen, + } + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if rhs := m.DeniedTables; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.DeniedTables = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Shard_TabletControl) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Shard) CloneVT() *Shard { + if m == nil { + return (*Shard)(nil) + } + r := &Shard{ + PrimaryAlias: m.PrimaryAlias.CloneVT(), + PrimaryTermStartTime: m.PrimaryTermStartTime.CloneVT(), + KeyRange: m.KeyRange.CloneVT(), + IsPrimaryServing: m.IsPrimaryServing, + } + if rhs := m.SourceShards; rhs != nil { + tmpContainer := make([]*Shard_SourceShard, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.SourceShards = tmpContainer + } + if rhs := m.TabletControls; rhs != nil { + tmpContainer := make([]*Shard_TabletControl, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.TabletControls = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Shard) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Keyspace_ServedFrom) CloneVT() *Keyspace_ServedFrom { + if m == nil { + return (*Keyspace_ServedFrom)(nil) + } + r := &Keyspace_ServedFrom{ + TabletType: m.TabletType, + Keyspace: m.Keyspace, + } + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Keyspace_ServedFrom) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Keyspace) CloneVT() *Keyspace { + if m == nil { + return (*Keyspace)(nil) + } + r := &Keyspace{ + KeyspaceType: m.KeyspaceType, + BaseKeyspace: m.BaseKeyspace, + SnapshotTime: m.SnapshotTime.CloneVT(), + DurabilityPolicy: m.DurabilityPolicy, + ThrottlerConfig: m.ThrottlerConfig.CloneVT(), + SidecarDbName: m.SidecarDbName, + } + if rhs := m.ServedFroms; rhs != nil { + tmpContainer := make([]*Keyspace_ServedFrom, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ServedFroms = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Keyspace) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ShardReplication_Node) CloneVT() *ShardReplication_Node { + if m == nil { + return (*ShardReplication_Node)(nil) + } + r := &ShardReplication_Node{ + TabletAlias: m.TabletAlias.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ShardReplication_Node) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ShardReplication) CloneVT() *ShardReplication { + if m == nil { + return (*ShardReplication)(nil) + } + r := &ShardReplication{} + if rhs := m.Nodes; rhs != nil { + tmpContainer := make([]*ShardReplication_Node, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Nodes = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ShardReplication) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ShardReplicationError) CloneVT() *ShardReplicationError { + if m == nil { + return (*ShardReplicationError)(nil) + } + r := &ShardReplicationError{ + Type: m.Type, + TabletAlias: m.TabletAlias.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ShardReplicationError) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ShardReference) CloneVT() *ShardReference { + if m == nil { + return (*ShardReference)(nil) + } + r := &ShardReference{ + Name: m.Name, + KeyRange: m.KeyRange.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ShardReference) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ShardTabletControl) CloneVT() *ShardTabletControl { + if m == nil { + return (*ShardTabletControl)(nil) + } + r := &ShardTabletControl{ + Name: m.Name, + KeyRange: m.KeyRange.CloneVT(), + QueryServiceDisabled: m.QueryServiceDisabled, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ShardTabletControl) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ThrottledAppRule) CloneVT() *ThrottledAppRule { + if m == nil { + return (*ThrottledAppRule)(nil) + } + r := &ThrottledAppRule{ + Name: m.Name, + Ratio: m.Ratio, + ExpiresAt: m.ExpiresAt.CloneVT(), + Exempt: m.Exempt, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ThrottledAppRule) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ThrottlerConfig) CloneVT() *ThrottlerConfig { + if m == nil { + return (*ThrottlerConfig)(nil) + } + r := &ThrottlerConfig{ + Enabled: m.Enabled, + Threshold: m.Threshold, + CustomQuery: m.CustomQuery, + CheckAsCheckSelf: m.CheckAsCheckSelf, + } + if rhs := m.ThrottledApps; rhs != nil { + tmpContainer := make(map[string]*ThrottledAppRule, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ThrottledApps = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ThrottlerConfig) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SrvKeyspace_KeyspacePartition) CloneVT() *SrvKeyspace_KeyspacePartition { + if m == nil { + return (*SrvKeyspace_KeyspacePartition)(nil) + } + r := &SrvKeyspace_KeyspacePartition{ + ServedType: m.ServedType, + } + if rhs := m.ShardReferences; rhs != nil { + tmpContainer := make([]*ShardReference, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ShardReferences = tmpContainer + } + if rhs := m.ShardTabletControls; rhs != nil { + tmpContainer := make([]*ShardTabletControl, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ShardTabletControls = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SrvKeyspace_KeyspacePartition) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SrvKeyspace_ServedFrom) CloneVT() *SrvKeyspace_ServedFrom { + if m == nil { + return (*SrvKeyspace_ServedFrom)(nil) + } + r := &SrvKeyspace_ServedFrom{ + TabletType: m.TabletType, + Keyspace: m.Keyspace, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SrvKeyspace_ServedFrom) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SrvKeyspace) CloneVT() *SrvKeyspace { + if m == nil { + return (*SrvKeyspace)(nil) + } + r := &SrvKeyspace{ + ThrottlerConfig: m.ThrottlerConfig.CloneVT(), + } + if rhs := m.Partitions; rhs != nil { + tmpContainer := make([]*SrvKeyspace_KeyspacePartition, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Partitions = tmpContainer + } + if rhs := m.ServedFrom; rhs != nil { + tmpContainer := make([]*SrvKeyspace_ServedFrom, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ServedFrom = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SrvKeyspace) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CellInfo) CloneVT() *CellInfo { + if m == nil { + return (*CellInfo)(nil) + } + r := &CellInfo{ + ServerAddress: m.ServerAddress, + Root: m.Root, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CellInfo) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CellsAlias) CloneVT() *CellsAlias { + if m == nil { + return (*CellsAlias)(nil) + } + r := &CellsAlias{} + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CellsAlias) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *TopoConfig) CloneVT() *TopoConfig { + if m == nil { + return (*TopoConfig)(nil) + } + r := &TopoConfig{ + TopoType: m.TopoType, + Server: m.Server, + Root: m.Root, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *TopoConfig) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExternalVitessCluster) CloneVT() *ExternalVitessCluster { + if m == nil { + return (*ExternalVitessCluster)(nil) + } + r := &ExternalVitessCluster{ + TopoConfig: m.TopoConfig.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExternalVitessCluster) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExternalClusters) CloneVT() *ExternalClusters { + if m == nil { + return (*ExternalClusters)(nil) + } + r := &ExternalClusters{} + if rhs := m.VitessCluster; rhs != nil { + tmpContainer := make([]*ExternalVitessCluster, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.VitessCluster = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExternalClusters) CloneMessageVT() proto.Message { + return m.CloneVT() +} + func (m *KeyRange) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil diff --git a/go/vt/proto/vschema/vschema_vtproto.pb.go b/go/vt/proto/vschema/vschema_vtproto.pb.go index 38d7a422834..89f6e38a69f 100644 --- a/go/vt/proto/vschema/vschema_vtproto.pb.go +++ b/go/vt/proto/vschema/vschema_vtproto.pb.go @@ -1,11 +1,12 @@ // Code generated by protoc-gen-go-vtproto. DO NOT EDIT. -// protoc-gen-go-vtproto version: v0.4.0 +// protoc-gen-go-vtproto version: v0.5.0 // source: vschema.proto package vschema import ( fmt "fmt" + proto "google.golang.org/protobuf/proto" protoimpl "google.golang.org/protobuf/runtime/protoimpl" io "io" bits "math/bits" @@ -19,6 +20,279 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +func (m *RoutingRules) CloneVT() *RoutingRules { + if m == nil { + return (*RoutingRules)(nil) + } + r := &RoutingRules{} + if rhs := m.Rules; rhs != nil { + tmpContainer := make([]*RoutingRule, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Rules = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RoutingRules) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RoutingRule) CloneVT() *RoutingRule { + if m == nil { + return (*RoutingRule)(nil) + } + r := &RoutingRule{ + FromTable: m.FromTable, + } + if rhs := m.ToTables; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ToTables = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RoutingRule) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Keyspace) CloneVT() *Keyspace { + if m == nil { + return (*Keyspace)(nil) + } + r := &Keyspace{ + Sharded: m.Sharded, + RequireExplicitRouting: m.RequireExplicitRouting, + ForeignKeyMode: m.ForeignKeyMode, + } + if rhs := m.Vindexes; rhs != nil { + tmpContainer := make(map[string]*Vindex, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Vindexes = tmpContainer + } + if rhs := m.Tables; rhs != nil { + tmpContainer := make(map[string]*Table, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Tables = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Keyspace) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Vindex) CloneVT() *Vindex { + if m == nil { + return (*Vindex)(nil) + } + r := &Vindex{ + Type: m.Type, + Owner: m.Owner, + } + if rhs := m.Params; rhs != nil { + tmpContainer := make(map[string]string, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.Params = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Vindex) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Table) CloneVT() *Table { + if m == nil { + return (*Table)(nil) + } + r := &Table{ + Type: m.Type, + AutoIncrement: m.AutoIncrement.CloneVT(), + Pinned: m.Pinned, + ColumnListAuthoritative: m.ColumnListAuthoritative, + Source: m.Source, + } + if rhs := m.ColumnVindexes; rhs != nil { + tmpContainer := make([]*ColumnVindex, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ColumnVindexes = tmpContainer + } + if rhs := m.Columns; rhs != nil { + tmpContainer := make([]*Column, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Columns = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Table) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ColumnVindex) CloneVT() *ColumnVindex { + if m == nil { + return (*ColumnVindex)(nil) + } + r := &ColumnVindex{ + Column: m.Column, + Name: m.Name, + } + if rhs := m.Columns; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Columns = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ColumnVindex) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *AutoIncrement) CloneVT() *AutoIncrement { + if m == nil { + return (*AutoIncrement)(nil) + } + r := &AutoIncrement{ + Column: m.Column, + Sequence: m.Sequence, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *AutoIncrement) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Column) CloneVT() *Column { + if m == nil { + return (*Column)(nil) + } + r := &Column{ + Name: m.Name, + Type: m.Type, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Column) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SrvVSchema) CloneVT() *SrvVSchema { + if m == nil { + return (*SrvVSchema)(nil) + } + r := &SrvVSchema{ + RoutingRules: m.RoutingRules.CloneVT(), + ShardRoutingRules: m.ShardRoutingRules.CloneVT(), + } + if rhs := m.Keyspaces; rhs != nil { + tmpContainer := make(map[string]*Keyspace, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Keyspaces = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SrvVSchema) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ShardRoutingRules) CloneVT() *ShardRoutingRules { + if m == nil { + return (*ShardRoutingRules)(nil) + } + r := &ShardRoutingRules{} + if rhs := m.Rules; rhs != nil { + tmpContainer := make([]*ShardRoutingRule, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Rules = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ShardRoutingRules) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ShardRoutingRule) CloneVT() *ShardRoutingRule { + if m == nil { + return (*ShardRoutingRule)(nil) + } + r := &ShardRoutingRule{ + FromKeyspace: m.FromKeyspace, + ToKeyspace: m.ToKeyspace, + Shard: m.Shard, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ShardRoutingRule) CloneMessageVT() proto.Message { + return m.CloneVT() +} + func (m *RoutingRules) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil diff --git a/go/vt/proto/vtadmin/vtadmin_vtproto.pb.go b/go/vt/proto/vtadmin/vtadmin_vtproto.pb.go index 10685461aed..0e4b4c6e84b 100644 --- a/go/vt/proto/vtadmin/vtadmin_vtproto.pb.go +++ b/go/vt/proto/vtadmin/vtadmin_vtproto.pb.go @@ -1,11 +1,12 @@ // Code generated by protoc-gen-go-vtproto. DO NOT EDIT. -// protoc-gen-go-vtproto version: v0.4.0 +// protoc-gen-go-vtproto version: v0.5.0 // source: vtadmin.proto package vtadmin import ( fmt "fmt" + proto "google.golang.org/protobuf/proto" protoimpl "google.golang.org/protobuf/runtime/protoimpl" io "io" bits "math/bits" @@ -24,6 +25,2344 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +func (m *Cluster) CloneVT() *Cluster { + if m == nil { + return (*Cluster)(nil) + } + r := &Cluster{ + Id: m.Id, + Name: m.Name, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Cluster) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ClusterBackup) CloneVT() *ClusterBackup { + if m == nil { + return (*ClusterBackup)(nil) + } + r := &ClusterBackup{ + Cluster: m.Cluster.CloneVT(), + Backup: m.Backup.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ClusterBackup) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ClusterCellsAliases) CloneVT() *ClusterCellsAliases { + if m == nil { + return (*ClusterCellsAliases)(nil) + } + r := &ClusterCellsAliases{ + Cluster: m.Cluster.CloneVT(), + } + if rhs := m.Aliases; rhs != nil { + tmpContainer := make(map[string]*topodata.CellsAlias, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Aliases = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ClusterCellsAliases) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ClusterCellInfo) CloneVT() *ClusterCellInfo { + if m == nil { + return (*ClusterCellInfo)(nil) + } + r := &ClusterCellInfo{ + Cluster: m.Cluster.CloneVT(), + Name: m.Name, + CellInfo: m.CellInfo.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ClusterCellInfo) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ClusterShardReplicationPosition) CloneVT() *ClusterShardReplicationPosition { + if m == nil { + return (*ClusterShardReplicationPosition)(nil) + } + r := &ClusterShardReplicationPosition{ + Cluster: m.Cluster.CloneVT(), + Keyspace: m.Keyspace, + Shard: m.Shard, + PositionInfo: m.PositionInfo.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ClusterShardReplicationPosition) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ClusterWorkflows) CloneVT() *ClusterWorkflows { + if m == nil { + return (*ClusterWorkflows)(nil) + } + r := &ClusterWorkflows{} + if rhs := m.Workflows; rhs != nil { + tmpContainer := make([]*Workflow, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Workflows = tmpContainer + } + if rhs := m.Warnings; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Warnings = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ClusterWorkflows) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Keyspace) CloneVT() *Keyspace { + if m == nil { + return (*Keyspace)(nil) + } + r := &Keyspace{ + Cluster: m.Cluster.CloneVT(), + Keyspace: m.Keyspace.CloneVT(), + } + if rhs := m.Shards; rhs != nil { + tmpContainer := make(map[string]*vtctldata.Shard, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Shards = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Keyspace) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Schema_ShardTableSize) CloneVT() *Schema_ShardTableSize { + if m == nil { + return (*Schema_ShardTableSize)(nil) + } + r := &Schema_ShardTableSize{ + RowCount: m.RowCount, + DataLength: m.DataLength, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Schema_ShardTableSize) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Schema_TableSize) CloneVT() *Schema_TableSize { + if m == nil { + return (*Schema_TableSize)(nil) + } + r := &Schema_TableSize{ + RowCount: m.RowCount, + DataLength: m.DataLength, + } + if rhs := m.ByShard; rhs != nil { + tmpContainer := make(map[string]*Schema_ShardTableSize, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ByShard = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Schema_TableSize) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Schema) CloneVT() *Schema { + if m == nil { + return (*Schema)(nil) + } + r := &Schema{ + Cluster: m.Cluster.CloneVT(), + Keyspace: m.Keyspace, + } + if rhs := m.TableDefinitions; rhs != nil { + tmpContainer := make([]*tabletmanagerdata.TableDefinition, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.TableDefinitions = tmpContainer + } + if rhs := m.TableSizes; rhs != nil { + tmpContainer := make(map[string]*Schema_TableSize, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.TableSizes = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Schema) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Shard) CloneVT() *Shard { + if m == nil { + return (*Shard)(nil) + } + r := &Shard{ + Cluster: m.Cluster.CloneVT(), + Shard: m.Shard.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Shard) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SrvVSchema) CloneVT() *SrvVSchema { + if m == nil { + return (*SrvVSchema)(nil) + } + r := &SrvVSchema{ + Cell: m.Cell, + Cluster: m.Cluster.CloneVT(), + SrvVSchema: m.SrvVSchema.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SrvVSchema) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Tablet) CloneVT() *Tablet { + if m == nil { + return (*Tablet)(nil) + } + r := &Tablet{ + Cluster: m.Cluster.CloneVT(), + Tablet: m.Tablet.CloneVT(), + State: m.State, + FQDN: m.FQDN, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Tablet) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VSchema) CloneVT() *VSchema { + if m == nil { + return (*VSchema)(nil) + } + r := &VSchema{ + Cluster: m.Cluster.CloneVT(), + Name: m.Name, + VSchema: m.VSchema.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VSchema) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Vtctld) CloneVT() *Vtctld { + if m == nil { + return (*Vtctld)(nil) + } + r := &Vtctld{ + Hostname: m.Hostname, + Cluster: m.Cluster.CloneVT(), + FQDN: m.FQDN, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Vtctld) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VTGate) CloneVT() *VTGate { + if m == nil { + return (*VTGate)(nil) + } + r := &VTGate{ + Hostname: m.Hostname, + Pool: m.Pool, + Cell: m.Cell, + Cluster: m.Cluster.CloneVT(), + FQDN: m.FQDN, + } + if rhs := m.Keyspaces; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Keyspaces = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VTGate) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Workflow) CloneVT() *Workflow { + if m == nil { + return (*Workflow)(nil) + } + r := &Workflow{ + Cluster: m.Cluster.CloneVT(), + Keyspace: m.Keyspace, + Workflow: m.Workflow.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Workflow) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CreateKeyspaceRequest) CloneVT() *CreateKeyspaceRequest { + if m == nil { + return (*CreateKeyspaceRequest)(nil) + } + r := &CreateKeyspaceRequest{ + ClusterId: m.ClusterId, + Options: m.Options.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CreateKeyspaceRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CreateKeyspaceResponse) CloneVT() *CreateKeyspaceResponse { + if m == nil { + return (*CreateKeyspaceResponse)(nil) + } + r := &CreateKeyspaceResponse{ + Keyspace: m.Keyspace.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CreateKeyspaceResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CreateShardRequest) CloneVT() *CreateShardRequest { + if m == nil { + return (*CreateShardRequest)(nil) + } + r := &CreateShardRequest{ + ClusterId: m.ClusterId, + Options: m.Options.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CreateShardRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DeleteKeyspaceRequest) CloneVT() *DeleteKeyspaceRequest { + if m == nil { + return (*DeleteKeyspaceRequest)(nil) + } + r := &DeleteKeyspaceRequest{ + ClusterId: m.ClusterId, + Options: m.Options.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DeleteKeyspaceRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DeleteShardsRequest) CloneVT() *DeleteShardsRequest { + if m == nil { + return (*DeleteShardsRequest)(nil) + } + r := &DeleteShardsRequest{ + ClusterId: m.ClusterId, + Options: m.Options.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DeleteShardsRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DeleteTabletRequest) CloneVT() *DeleteTabletRequest { + if m == nil { + return (*DeleteTabletRequest)(nil) + } + r := &DeleteTabletRequest{ + Alias: m.Alias.CloneVT(), + AllowPrimary: m.AllowPrimary, + } + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DeleteTabletRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DeleteTabletResponse) CloneVT() *DeleteTabletResponse { + if m == nil { + return (*DeleteTabletResponse)(nil) + } + r := &DeleteTabletResponse{ + Status: m.Status, + Cluster: m.Cluster.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DeleteTabletResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *EmergencyFailoverShardRequest) CloneVT() *EmergencyFailoverShardRequest { + if m == nil { + return (*EmergencyFailoverShardRequest)(nil) + } + r := &EmergencyFailoverShardRequest{ + ClusterId: m.ClusterId, + Options: m.Options.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *EmergencyFailoverShardRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *EmergencyFailoverShardResponse) CloneVT() *EmergencyFailoverShardResponse { + if m == nil { + return (*EmergencyFailoverShardResponse)(nil) + } + r := &EmergencyFailoverShardResponse{ + Cluster: m.Cluster.CloneVT(), + Keyspace: m.Keyspace, + Shard: m.Shard, + PromotedPrimary: m.PromotedPrimary.CloneVT(), + } + if rhs := m.Events; rhs != nil { + tmpContainer := make([]*logutil.Event, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Events = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *EmergencyFailoverShardResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *FindSchemaRequest) CloneVT() *FindSchemaRequest { + if m == nil { + return (*FindSchemaRequest)(nil) + } + r := &FindSchemaRequest{ + Table: m.Table, + TableSizeOptions: m.TableSizeOptions.CloneVT(), + } + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *FindSchemaRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetBackupsRequest) CloneVT() *GetBackupsRequest { + if m == nil { + return (*GetBackupsRequest)(nil) + } + r := &GetBackupsRequest{ + RequestOptions: m.RequestOptions.CloneVT(), + } + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if rhs := m.Keyspaces; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Keyspaces = tmpContainer + } + if rhs := m.KeyspaceShards; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.KeyspaceShards = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetBackupsRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetBackupsResponse) CloneVT() *GetBackupsResponse { + if m == nil { + return (*GetBackupsResponse)(nil) + } + r := &GetBackupsResponse{} + if rhs := m.Backups; rhs != nil { + tmpContainer := make([]*ClusterBackup, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Backups = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetBackupsResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetCellInfosRequest) CloneVT() *GetCellInfosRequest { + if m == nil { + return (*GetCellInfosRequest)(nil) + } + r := &GetCellInfosRequest{ + NamesOnly: m.NamesOnly, + } + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetCellInfosRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetCellInfosResponse) CloneVT() *GetCellInfosResponse { + if m == nil { + return (*GetCellInfosResponse)(nil) + } + r := &GetCellInfosResponse{} + if rhs := m.CellInfos; rhs != nil { + tmpContainer := make([]*ClusterCellInfo, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.CellInfos = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetCellInfosResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetCellsAliasesRequest) CloneVT() *GetCellsAliasesRequest { + if m == nil { + return (*GetCellsAliasesRequest)(nil) + } + r := &GetCellsAliasesRequest{} + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetCellsAliasesRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetCellsAliasesResponse) CloneVT() *GetCellsAliasesResponse { + if m == nil { + return (*GetCellsAliasesResponse)(nil) + } + r := &GetCellsAliasesResponse{} + if rhs := m.Aliases; rhs != nil { + tmpContainer := make([]*ClusterCellsAliases, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Aliases = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetCellsAliasesResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetClustersRequest) CloneVT() *GetClustersRequest { + if m == nil { + return (*GetClustersRequest)(nil) + } + r := &GetClustersRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetClustersRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetClustersResponse) CloneVT() *GetClustersResponse { + if m == nil { + return (*GetClustersResponse)(nil) + } + r := &GetClustersResponse{} + if rhs := m.Clusters; rhs != nil { + tmpContainer := make([]*Cluster, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Clusters = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetClustersResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetFullStatusRequest) CloneVT() *GetFullStatusRequest { + if m == nil { + return (*GetFullStatusRequest)(nil) + } + r := &GetFullStatusRequest{ + ClusterId: m.ClusterId, + Alias: m.Alias.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetFullStatusRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetGatesRequest) CloneVT() *GetGatesRequest { + if m == nil { + return (*GetGatesRequest)(nil) + } + r := &GetGatesRequest{} + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetGatesRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetGatesResponse) CloneVT() *GetGatesResponse { + if m == nil { + return (*GetGatesResponse)(nil) + } + r := &GetGatesResponse{} + if rhs := m.Gates; rhs != nil { + tmpContainer := make([]*VTGate, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Gates = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetGatesResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetKeyspaceRequest) CloneVT() *GetKeyspaceRequest { + if m == nil { + return (*GetKeyspaceRequest)(nil) + } + r := &GetKeyspaceRequest{ + ClusterId: m.ClusterId, + Keyspace: m.Keyspace, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetKeyspaceRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetKeyspacesRequest) CloneVT() *GetKeyspacesRequest { + if m == nil { + return (*GetKeyspacesRequest)(nil) + } + r := &GetKeyspacesRequest{} + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetKeyspacesRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetKeyspacesResponse) CloneVT() *GetKeyspacesResponse { + if m == nil { + return (*GetKeyspacesResponse)(nil) + } + r := &GetKeyspacesResponse{} + if rhs := m.Keyspaces; rhs != nil { + tmpContainer := make([]*Keyspace, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Keyspaces = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetKeyspacesResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSchemaRequest) CloneVT() *GetSchemaRequest { + if m == nil { + return (*GetSchemaRequest)(nil) + } + r := &GetSchemaRequest{ + ClusterId: m.ClusterId, + Keyspace: m.Keyspace, + Table: m.Table, + TableSizeOptions: m.TableSizeOptions.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSchemaRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSchemasRequest) CloneVT() *GetSchemasRequest { + if m == nil { + return (*GetSchemasRequest)(nil) + } + r := &GetSchemasRequest{ + TableSizeOptions: m.TableSizeOptions.CloneVT(), + } + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSchemasRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSchemasResponse) CloneVT() *GetSchemasResponse { + if m == nil { + return (*GetSchemasResponse)(nil) + } + r := &GetSchemasResponse{} + if rhs := m.Schemas; rhs != nil { + tmpContainer := make([]*Schema, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Schemas = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSchemasResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetShardReplicationPositionsRequest) CloneVT() *GetShardReplicationPositionsRequest { + if m == nil { + return (*GetShardReplicationPositionsRequest)(nil) + } + r := &GetShardReplicationPositionsRequest{} + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if rhs := m.Keyspaces; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Keyspaces = tmpContainer + } + if rhs := m.KeyspaceShards; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.KeyspaceShards = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetShardReplicationPositionsRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetShardReplicationPositionsResponse) CloneVT() *GetShardReplicationPositionsResponse { + if m == nil { + return (*GetShardReplicationPositionsResponse)(nil) + } + r := &GetShardReplicationPositionsResponse{} + if rhs := m.ReplicationPositions; rhs != nil { + tmpContainer := make([]*ClusterShardReplicationPosition, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ReplicationPositions = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetShardReplicationPositionsResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSrvKeyspaceRequest) CloneVT() *GetSrvKeyspaceRequest { + if m == nil { + return (*GetSrvKeyspaceRequest)(nil) + } + r := &GetSrvKeyspaceRequest{ + ClusterId: m.ClusterId, + Keyspace: m.Keyspace, + } + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSrvKeyspaceRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSrvKeyspacesRequest) CloneVT() *GetSrvKeyspacesRequest { + if m == nil { + return (*GetSrvKeyspacesRequest)(nil) + } + r := &GetSrvKeyspacesRequest{} + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSrvKeyspacesRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSrvKeyspacesResponse) CloneVT() *GetSrvKeyspacesResponse { + if m == nil { + return (*GetSrvKeyspacesResponse)(nil) + } + r := &GetSrvKeyspacesResponse{} + if rhs := m.SrvKeyspaces; rhs != nil { + tmpContainer := make(map[string]*vtctldata.GetSrvKeyspacesResponse, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.SrvKeyspaces = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSrvKeyspacesResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSrvVSchemaRequest) CloneVT() *GetSrvVSchemaRequest { + if m == nil { + return (*GetSrvVSchemaRequest)(nil) + } + r := &GetSrvVSchemaRequest{ + ClusterId: m.ClusterId, + Cell: m.Cell, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSrvVSchemaRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSrvVSchemasRequest) CloneVT() *GetSrvVSchemasRequest { + if m == nil { + return (*GetSrvVSchemasRequest)(nil) + } + r := &GetSrvVSchemasRequest{} + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSrvVSchemasRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSrvVSchemasResponse) CloneVT() *GetSrvVSchemasResponse { + if m == nil { + return (*GetSrvVSchemasResponse)(nil) + } + r := &GetSrvVSchemasResponse{} + if rhs := m.SrvVSchemas; rhs != nil { + tmpContainer := make([]*SrvVSchema, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.SrvVSchemas = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSrvVSchemasResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSchemaTableSizeOptions) CloneVT() *GetSchemaTableSizeOptions { + if m == nil { + return (*GetSchemaTableSizeOptions)(nil) + } + r := &GetSchemaTableSizeOptions{ + AggregateSizes: m.AggregateSizes, + IncludeNonServingShards: m.IncludeNonServingShards, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSchemaTableSizeOptions) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetTabletRequest) CloneVT() *GetTabletRequest { + if m == nil { + return (*GetTabletRequest)(nil) + } + r := &GetTabletRequest{ + Alias: m.Alias.CloneVT(), + } + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetTabletRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetTabletsRequest) CloneVT() *GetTabletsRequest { + if m == nil { + return (*GetTabletsRequest)(nil) + } + r := &GetTabletsRequest{} + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetTabletsRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetTabletsResponse) CloneVT() *GetTabletsResponse { + if m == nil { + return (*GetTabletsResponse)(nil) + } + r := &GetTabletsResponse{} + if rhs := m.Tablets; rhs != nil { + tmpContainer := make([]*Tablet, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Tablets = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetTabletsResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetTopologyPathRequest) CloneVT() *GetTopologyPathRequest { + if m == nil { + return (*GetTopologyPathRequest)(nil) + } + r := &GetTopologyPathRequest{ + ClusterId: m.ClusterId, + Path: m.Path, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetTopologyPathRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetVSchemaRequest) CloneVT() *GetVSchemaRequest { + if m == nil { + return (*GetVSchemaRequest)(nil) + } + r := &GetVSchemaRequest{ + ClusterId: m.ClusterId, + Keyspace: m.Keyspace, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetVSchemaRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetVSchemasRequest) CloneVT() *GetVSchemasRequest { + if m == nil { + return (*GetVSchemasRequest)(nil) + } + r := &GetVSchemasRequest{} + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetVSchemasRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetVSchemasResponse) CloneVT() *GetVSchemasResponse { + if m == nil { + return (*GetVSchemasResponse)(nil) + } + r := &GetVSchemasResponse{} + if rhs := m.VSchemas; rhs != nil { + tmpContainer := make([]*VSchema, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.VSchemas = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetVSchemasResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetVtctldsRequest) CloneVT() *GetVtctldsRequest { + if m == nil { + return (*GetVtctldsRequest)(nil) + } + r := &GetVtctldsRequest{} + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetVtctldsRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetVtctldsResponse) CloneVT() *GetVtctldsResponse { + if m == nil { + return (*GetVtctldsResponse)(nil) + } + r := &GetVtctldsResponse{} + if rhs := m.Vtctlds; rhs != nil { + tmpContainer := make([]*Vtctld, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Vtctlds = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetVtctldsResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetWorkflowRequest) CloneVT() *GetWorkflowRequest { + if m == nil { + return (*GetWorkflowRequest)(nil) + } + r := &GetWorkflowRequest{ + ClusterId: m.ClusterId, + Keyspace: m.Keyspace, + Name: m.Name, + ActiveOnly: m.ActiveOnly, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetWorkflowRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetWorkflowsRequest) CloneVT() *GetWorkflowsRequest { + if m == nil { + return (*GetWorkflowsRequest)(nil) + } + r := &GetWorkflowsRequest{ + ActiveOnly: m.ActiveOnly, + } + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if rhs := m.Keyspaces; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Keyspaces = tmpContainer + } + if rhs := m.IgnoreKeyspaces; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.IgnoreKeyspaces = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetWorkflowsRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetWorkflowsResponse) CloneVT() *GetWorkflowsResponse { + if m == nil { + return (*GetWorkflowsResponse)(nil) + } + r := &GetWorkflowsResponse{} + if rhs := m.WorkflowsByCluster; rhs != nil { + tmpContainer := make(map[string]*ClusterWorkflows, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.WorkflowsByCluster = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetWorkflowsResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PingTabletRequest) CloneVT() *PingTabletRequest { + if m == nil { + return (*PingTabletRequest)(nil) + } + r := &PingTabletRequest{ + Alias: m.Alias.CloneVT(), + } + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PingTabletRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PingTabletResponse) CloneVT() *PingTabletResponse { + if m == nil { + return (*PingTabletResponse)(nil) + } + r := &PingTabletResponse{ + Status: m.Status, + Cluster: m.Cluster.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PingTabletResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PlannedFailoverShardRequest) CloneVT() *PlannedFailoverShardRequest { + if m == nil { + return (*PlannedFailoverShardRequest)(nil) + } + r := &PlannedFailoverShardRequest{ + ClusterId: m.ClusterId, + Options: m.Options.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PlannedFailoverShardRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PlannedFailoverShardResponse) CloneVT() *PlannedFailoverShardResponse { + if m == nil { + return (*PlannedFailoverShardResponse)(nil) + } + r := &PlannedFailoverShardResponse{ + Cluster: m.Cluster.CloneVT(), + Keyspace: m.Keyspace, + Shard: m.Shard, + PromotedPrimary: m.PromotedPrimary.CloneVT(), + } + if rhs := m.Events; rhs != nil { + tmpContainer := make([]*logutil.Event, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Events = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PlannedFailoverShardResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RebuildKeyspaceGraphRequest) CloneVT() *RebuildKeyspaceGraphRequest { + if m == nil { + return (*RebuildKeyspaceGraphRequest)(nil) + } + r := &RebuildKeyspaceGraphRequest{ + ClusterId: m.ClusterId, + Keyspace: m.Keyspace, + AllowPartial: m.AllowPartial, + } + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RebuildKeyspaceGraphRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RebuildKeyspaceGraphResponse) CloneVT() *RebuildKeyspaceGraphResponse { + if m == nil { + return (*RebuildKeyspaceGraphResponse)(nil) + } + r := &RebuildKeyspaceGraphResponse{ + Status: m.Status, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RebuildKeyspaceGraphResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RefreshStateRequest) CloneVT() *RefreshStateRequest { + if m == nil { + return (*RefreshStateRequest)(nil) + } + r := &RefreshStateRequest{ + Alias: m.Alias.CloneVT(), + } + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RefreshStateRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RefreshStateResponse) CloneVT() *RefreshStateResponse { + if m == nil { + return (*RefreshStateResponse)(nil) + } + r := &RefreshStateResponse{ + Status: m.Status, + Cluster: m.Cluster.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RefreshStateResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReloadSchemasRequest) CloneVT() *ReloadSchemasRequest { + if m == nil { + return (*ReloadSchemasRequest)(nil) + } + r := &ReloadSchemasRequest{ + Concurrency: m.Concurrency, + WaitPosition: m.WaitPosition, + IncludePrimary: m.IncludePrimary, + } + if rhs := m.Keyspaces; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Keyspaces = tmpContainer + } + if rhs := m.KeyspaceShards; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.KeyspaceShards = tmpContainer + } + if rhs := m.Tablets; rhs != nil { + tmpContainer := make([]*topodata.TabletAlias, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Tablets = tmpContainer + } + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReloadSchemasRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReloadSchemasResponse_KeyspaceResult) CloneVT() *ReloadSchemasResponse_KeyspaceResult { + if m == nil { + return (*ReloadSchemasResponse_KeyspaceResult)(nil) + } + r := &ReloadSchemasResponse_KeyspaceResult{ + Keyspace: m.Keyspace.CloneVT(), + } + if rhs := m.Events; rhs != nil { + tmpContainer := make([]*logutil.Event, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Events = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReloadSchemasResponse_KeyspaceResult) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReloadSchemasResponse_ShardResult) CloneVT() *ReloadSchemasResponse_ShardResult { + if m == nil { + return (*ReloadSchemasResponse_ShardResult)(nil) + } + r := &ReloadSchemasResponse_ShardResult{ + Shard: m.Shard.CloneVT(), + } + if rhs := m.Events; rhs != nil { + tmpContainer := make([]*logutil.Event, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Events = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReloadSchemasResponse_ShardResult) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReloadSchemasResponse_TabletResult) CloneVT() *ReloadSchemasResponse_TabletResult { + if m == nil { + return (*ReloadSchemasResponse_TabletResult)(nil) + } + r := &ReloadSchemasResponse_TabletResult{ + Tablet: m.Tablet.CloneVT(), + Result: m.Result, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReloadSchemasResponse_TabletResult) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReloadSchemasResponse) CloneVT() *ReloadSchemasResponse { + if m == nil { + return (*ReloadSchemasResponse)(nil) + } + r := &ReloadSchemasResponse{} + if rhs := m.KeyspaceResults; rhs != nil { + tmpContainer := make([]*ReloadSchemasResponse_KeyspaceResult, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.KeyspaceResults = tmpContainer + } + if rhs := m.ShardResults; rhs != nil { + tmpContainer := make([]*ReloadSchemasResponse_ShardResult, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ShardResults = tmpContainer + } + if rhs := m.TabletResults; rhs != nil { + tmpContainer := make([]*ReloadSchemasResponse_TabletResult, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.TabletResults = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReloadSchemasResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReloadSchemaShardRequest) CloneVT() *ReloadSchemaShardRequest { + if m == nil { + return (*ReloadSchemaShardRequest)(nil) + } + r := &ReloadSchemaShardRequest{ + ClusterId: m.ClusterId, + Keyspace: m.Keyspace, + Shard: m.Shard, + WaitPosition: m.WaitPosition, + IncludePrimary: m.IncludePrimary, + Concurrency: m.Concurrency, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReloadSchemaShardRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReloadSchemaShardResponse) CloneVT() *ReloadSchemaShardResponse { + if m == nil { + return (*ReloadSchemaShardResponse)(nil) + } + r := &ReloadSchemaShardResponse{} + if rhs := m.Events; rhs != nil { + tmpContainer := make([]*logutil.Event, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Events = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReloadSchemaShardResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RefreshTabletReplicationSourceRequest) CloneVT() *RefreshTabletReplicationSourceRequest { + if m == nil { + return (*RefreshTabletReplicationSourceRequest)(nil) + } + r := &RefreshTabletReplicationSourceRequest{ + Alias: m.Alias.CloneVT(), + } + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RefreshTabletReplicationSourceRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RefreshTabletReplicationSourceResponse) CloneVT() *RefreshTabletReplicationSourceResponse { + if m == nil { + return (*RefreshTabletReplicationSourceResponse)(nil) + } + r := &RefreshTabletReplicationSourceResponse{ + Keyspace: m.Keyspace, + Shard: m.Shard, + Primary: m.Primary.CloneVT(), + Cluster: m.Cluster.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RefreshTabletReplicationSourceResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RemoveKeyspaceCellRequest) CloneVT() *RemoveKeyspaceCellRequest { + if m == nil { + return (*RemoveKeyspaceCellRequest)(nil) + } + r := &RemoveKeyspaceCellRequest{ + ClusterId: m.ClusterId, + Keyspace: m.Keyspace, + Cell: m.Cell, + Force: m.Force, + Recursive: m.Recursive, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RemoveKeyspaceCellRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RemoveKeyspaceCellResponse) CloneVT() *RemoveKeyspaceCellResponse { + if m == nil { + return (*RemoveKeyspaceCellResponse)(nil) + } + r := &RemoveKeyspaceCellResponse{ + Status: m.Status, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RemoveKeyspaceCellResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RunHealthCheckRequest) CloneVT() *RunHealthCheckRequest { + if m == nil { + return (*RunHealthCheckRequest)(nil) + } + r := &RunHealthCheckRequest{ + Alias: m.Alias.CloneVT(), + } + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RunHealthCheckRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RunHealthCheckResponse) CloneVT() *RunHealthCheckResponse { + if m == nil { + return (*RunHealthCheckResponse)(nil) + } + r := &RunHealthCheckResponse{ + Status: m.Status, + Cluster: m.Cluster.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RunHealthCheckResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetReadOnlyRequest) CloneVT() *SetReadOnlyRequest { + if m == nil { + return (*SetReadOnlyRequest)(nil) + } + r := &SetReadOnlyRequest{ + Alias: m.Alias.CloneVT(), + } + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetReadOnlyRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetReadOnlyResponse) CloneVT() *SetReadOnlyResponse { + if m == nil { + return (*SetReadOnlyResponse)(nil) + } + r := &SetReadOnlyResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetReadOnlyResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetReadWriteRequest) CloneVT() *SetReadWriteRequest { + if m == nil { + return (*SetReadWriteRequest)(nil) + } + r := &SetReadWriteRequest{ + Alias: m.Alias.CloneVT(), + } + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetReadWriteRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetReadWriteResponse) CloneVT() *SetReadWriteResponse { + if m == nil { + return (*SetReadWriteResponse)(nil) + } + r := &SetReadWriteResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetReadWriteResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StartReplicationRequest) CloneVT() *StartReplicationRequest { + if m == nil { + return (*StartReplicationRequest)(nil) + } + r := &StartReplicationRequest{ + Alias: m.Alias.CloneVT(), + } + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StartReplicationRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StartReplicationResponse) CloneVT() *StartReplicationResponse { + if m == nil { + return (*StartReplicationResponse)(nil) + } + r := &StartReplicationResponse{ + Status: m.Status, + Cluster: m.Cluster.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StartReplicationResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StopReplicationRequest) CloneVT() *StopReplicationRequest { + if m == nil { + return (*StopReplicationRequest)(nil) + } + r := &StopReplicationRequest{ + Alias: m.Alias.CloneVT(), + } + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StopReplicationRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StopReplicationResponse) CloneVT() *StopReplicationResponse { + if m == nil { + return (*StopReplicationResponse)(nil) + } + r := &StopReplicationResponse{ + Status: m.Status, + Cluster: m.Cluster.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StopReplicationResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *TabletExternallyPromotedRequest) CloneVT() *TabletExternallyPromotedRequest { + if m == nil { + return (*TabletExternallyPromotedRequest)(nil) + } + r := &TabletExternallyPromotedRequest{ + Alias: m.Alias.CloneVT(), + } + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *TabletExternallyPromotedRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *TabletExternallyPromotedResponse) CloneVT() *TabletExternallyPromotedResponse { + if m == nil { + return (*TabletExternallyPromotedResponse)(nil) + } + r := &TabletExternallyPromotedResponse{ + Cluster: m.Cluster.CloneVT(), + Keyspace: m.Keyspace, + Shard: m.Shard, + NewPrimary: m.NewPrimary.CloneVT(), + OldPrimary: m.OldPrimary.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *TabletExternallyPromotedResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *TabletExternallyReparentedRequest) CloneVT() *TabletExternallyReparentedRequest { + if m == nil { + return (*TabletExternallyReparentedRequest)(nil) + } + r := &TabletExternallyReparentedRequest{ + Alias: m.Alias.CloneVT(), + } + if rhs := m.ClusterIds; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ClusterIds = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *TabletExternallyReparentedRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ValidateRequest) CloneVT() *ValidateRequest { + if m == nil { + return (*ValidateRequest)(nil) + } + r := &ValidateRequest{ + ClusterId: m.ClusterId, + PingTablets: m.PingTablets, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ValidateRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ValidateKeyspaceRequest) CloneVT() *ValidateKeyspaceRequest { + if m == nil { + return (*ValidateKeyspaceRequest)(nil) + } + r := &ValidateKeyspaceRequest{ + ClusterId: m.ClusterId, + Keyspace: m.Keyspace, + PingTablets: m.PingTablets, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ValidateKeyspaceRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ValidateSchemaKeyspaceRequest) CloneVT() *ValidateSchemaKeyspaceRequest { + if m == nil { + return (*ValidateSchemaKeyspaceRequest)(nil) + } + r := &ValidateSchemaKeyspaceRequest{ + ClusterId: m.ClusterId, + Keyspace: m.Keyspace, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ValidateSchemaKeyspaceRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ValidateShardRequest) CloneVT() *ValidateShardRequest { + if m == nil { + return (*ValidateShardRequest)(nil) + } + r := &ValidateShardRequest{ + ClusterId: m.ClusterId, + Keyspace: m.Keyspace, + Shard: m.Shard, + PingTablets: m.PingTablets, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ValidateShardRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ValidateVersionKeyspaceRequest) CloneVT() *ValidateVersionKeyspaceRequest { + if m == nil { + return (*ValidateVersionKeyspaceRequest)(nil) + } + r := &ValidateVersionKeyspaceRequest{ + ClusterId: m.ClusterId, + Keyspace: m.Keyspace, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ValidateVersionKeyspaceRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ValidateVersionShardRequest) CloneVT() *ValidateVersionShardRequest { + if m == nil { + return (*ValidateVersionShardRequest)(nil) + } + r := &ValidateVersionShardRequest{ + ClusterId: m.ClusterId, + Keyspace: m.Keyspace, + Shard: m.Shard, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ValidateVersionShardRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VTExplainRequest) CloneVT() *VTExplainRequest { + if m == nil { + return (*VTExplainRequest)(nil) + } + r := &VTExplainRequest{ + Cluster: m.Cluster, + Keyspace: m.Keyspace, + Sql: m.Sql, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VTExplainRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VTExplainResponse) CloneVT() *VTExplainResponse { + if m == nil { + return (*VTExplainResponse)(nil) + } + r := &VTExplainResponse{ + Response: m.Response, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VTExplainResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + func (m *Cluster) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil diff --git a/go/vt/proto/vtctldata/vtctldata_vtproto.pb.go b/go/vt/proto/vtctldata/vtctldata_vtproto.pb.go index e65ff01a57c..973a3610d05 100644 --- a/go/vt/proto/vtctldata/vtctldata_vtproto.pb.go +++ b/go/vt/proto/vtctldata/vtctldata_vtproto.pb.go @@ -1,5 +1,5 @@ // Code generated by protoc-gen-go-vtproto. DO NOT EDIT. -// protoc-gen-go-vtproto version: v0.4.0 +// protoc-gen-go-vtproto version: v0.5.0 // source: vtctldata.proto package vtctldata @@ -7,6 +7,7 @@ package vtctldata import ( binary "encoding/binary" fmt "fmt" + proto "google.golang.org/protobuf/proto" protoimpl "google.golang.org/protobuf/runtime/protoimpl" io "io" math "math" @@ -30,6 +31,4624 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +func (m *ExecuteVtctlCommandRequest) CloneVT() *ExecuteVtctlCommandRequest { + if m == nil { + return (*ExecuteVtctlCommandRequest)(nil) + } + r := &ExecuteVtctlCommandRequest{ + ActionTimeout: m.ActionTimeout, + } + if rhs := m.Args; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Args = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteVtctlCommandRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteVtctlCommandResponse) CloneVT() *ExecuteVtctlCommandResponse { + if m == nil { + return (*ExecuteVtctlCommandResponse)(nil) + } + r := &ExecuteVtctlCommandResponse{ + Event: m.Event.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteVtctlCommandResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *TableMaterializeSettings) CloneVT() *TableMaterializeSettings { + if m == nil { + return (*TableMaterializeSettings)(nil) + } + r := &TableMaterializeSettings{ + TargetTable: m.TargetTable, + SourceExpression: m.SourceExpression, + CreateDdl: m.CreateDdl, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *TableMaterializeSettings) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *MaterializeSettings) CloneVT() *MaterializeSettings { + if m == nil { + return (*MaterializeSettings)(nil) + } + r := &MaterializeSettings{ + Workflow: m.Workflow, + SourceKeyspace: m.SourceKeyspace, + TargetKeyspace: m.TargetKeyspace, + StopAfterCopy: m.StopAfterCopy, + Cell: m.Cell, + TabletTypes: m.TabletTypes, + ExternalCluster: m.ExternalCluster, + MaterializationIntent: m.MaterializationIntent, + SourceTimeZone: m.SourceTimeZone, + TargetTimeZone: m.TargetTimeZone, + OnDdl: m.OnDdl, + DeferSecondaryKeys: m.DeferSecondaryKeys, + TabletSelectionPreference: m.TabletSelectionPreference, + } + if rhs := m.TableSettings; rhs != nil { + tmpContainer := make([]*TableMaterializeSettings, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.TableSettings = tmpContainer + } + if rhs := m.SourceShards; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.SourceShards = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *MaterializeSettings) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Keyspace) CloneVT() *Keyspace { + if m == nil { + return (*Keyspace)(nil) + } + r := &Keyspace{ + Name: m.Name, + Keyspace: m.Keyspace.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Keyspace) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SchemaMigration) CloneVT() *SchemaMigration { + if m == nil { + return (*SchemaMigration)(nil) + } + r := &SchemaMigration{ + Uuid: m.Uuid, + Keyspace: m.Keyspace, + Shard: m.Shard, + Schema: m.Schema, + Table: m.Table, + MigrationStatement: m.MigrationStatement, + Strategy: m.Strategy, + Options: m.Options, + AddedAt: m.AddedAt.CloneVT(), + RequestedAt: m.RequestedAt.CloneVT(), + ReadyAt: m.ReadyAt.CloneVT(), + StartedAt: m.StartedAt.CloneVT(), + LivenessTimestamp: m.LivenessTimestamp.CloneVT(), + CompletedAt: m.CompletedAt.CloneVT(), + CleanedUpAt: m.CleanedUpAt.CloneVT(), + Status: m.Status, + LogPath: m.LogPath, + Artifacts: m.Artifacts, + Retries: m.Retries, + Tablet: m.Tablet.CloneVT(), + TabletFailure: m.TabletFailure, + Progress: m.Progress, + MigrationContext: m.MigrationContext, + DdlAction: m.DdlAction, + Message: m.Message, + EtaSeconds: m.EtaSeconds, + RowsCopied: m.RowsCopied, + TableRows: m.TableRows, + AddedUniqueKeys: m.AddedUniqueKeys, + RemovedUniqueKeys: m.RemovedUniqueKeys, + LogFile: m.LogFile, + ArtifactRetention: m.ArtifactRetention.CloneVT(), + PostponeCompletion: m.PostponeCompletion, + RemovedUniqueKeyNames: m.RemovedUniqueKeyNames, + DroppedNoDefaultColumnNames: m.DroppedNoDefaultColumnNames, + ExpandedColumnNames: m.ExpandedColumnNames, + RevertibleNotes: m.RevertibleNotes, + AllowConcurrent: m.AllowConcurrent, + RevertedUuid: m.RevertedUuid, + IsView: m.IsView, + ReadyToComplete: m.ReadyToComplete, + VitessLivenessIndicator: m.VitessLivenessIndicator, + UserThrottleRatio: m.UserThrottleRatio, + SpecialPlan: m.SpecialPlan, + LastThrottledAt: m.LastThrottledAt.CloneVT(), + ComponentThrottled: m.ComponentThrottled, + CancelledAt: m.CancelledAt.CloneVT(), + PostponeLaunch: m.PostponeLaunch, + Stage: m.Stage, + CutoverAttempts: m.CutoverAttempts, + IsImmediateOperation: m.IsImmediateOperation, + ReviewedAt: m.ReviewedAt.CloneVT(), + ReadyToCompleteAt: m.ReadyToCompleteAt.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SchemaMigration) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Shard) CloneVT() *Shard { + if m == nil { + return (*Shard)(nil) + } + r := &Shard{ + Keyspace: m.Keyspace, + Name: m.Name, + Shard: m.Shard.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Shard) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Workflow_ReplicationLocation) CloneVT() *Workflow_ReplicationLocation { + if m == nil { + return (*Workflow_ReplicationLocation)(nil) + } + r := &Workflow_ReplicationLocation{ + Keyspace: m.Keyspace, + } + if rhs := m.Shards; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Shards = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Workflow_ReplicationLocation) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Workflow_ShardStream) CloneVT() *Workflow_ShardStream { + if m == nil { + return (*Workflow_ShardStream)(nil) + } + r := &Workflow_ShardStream{ + IsPrimaryServing: m.IsPrimaryServing, + } + if rhs := m.Streams; rhs != nil { + tmpContainer := make([]*Workflow_Stream, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Streams = tmpContainer + } + if rhs := m.TabletControls; rhs != nil { + tmpContainer := make([]*topodata.Shard_TabletControl, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.TabletControls = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Workflow_ShardStream) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Workflow_Stream_CopyState) CloneVT() *Workflow_Stream_CopyState { + if m == nil { + return (*Workflow_Stream_CopyState)(nil) + } + r := &Workflow_Stream_CopyState{ + Table: m.Table, + LastPk: m.LastPk, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Workflow_Stream_CopyState) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Workflow_Stream_Log) CloneVT() *Workflow_Stream_Log { + if m == nil { + return (*Workflow_Stream_Log)(nil) + } + r := &Workflow_Stream_Log{ + Id: m.Id, + StreamId: m.StreamId, + Type: m.Type, + State: m.State, + CreatedAt: m.CreatedAt.CloneVT(), + UpdatedAt: m.UpdatedAt.CloneVT(), + Message: m.Message, + Count: m.Count, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Workflow_Stream_Log) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Workflow_Stream) CloneVT() *Workflow_Stream { + if m == nil { + return (*Workflow_Stream)(nil) + } + r := &Workflow_Stream{ + Id: m.Id, + Shard: m.Shard, + Tablet: m.Tablet.CloneVT(), + BinlogSource: m.BinlogSource.CloneVT(), + Position: m.Position, + StopPosition: m.StopPosition, + State: m.State, + DbName: m.DbName, + TransactionTimestamp: m.TransactionTimestamp.CloneVT(), + TimeUpdated: m.TimeUpdated.CloneVT(), + Message: m.Message, + LogFetchError: m.LogFetchError, + } + if rhs := m.CopyStates; rhs != nil { + tmpContainer := make([]*Workflow_Stream_CopyState, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.CopyStates = tmpContainer + } + if rhs := m.Logs; rhs != nil { + tmpContainer := make([]*Workflow_Stream_Log, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Logs = tmpContainer + } + if rhs := m.Tags; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Tags = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Workflow_Stream) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Workflow) CloneVT() *Workflow { + if m == nil { + return (*Workflow)(nil) + } + r := &Workflow{ + Name: m.Name, + Source: m.Source.CloneVT(), + Target: m.Target.CloneVT(), + MaxVReplicationLag: m.MaxVReplicationLag, + WorkflowType: m.WorkflowType, + WorkflowSubType: m.WorkflowSubType, + } + if rhs := m.ShardStreams; rhs != nil { + tmpContainer := make(map[string]*Workflow_ShardStream, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ShardStreams = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Workflow) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *AddCellInfoRequest) CloneVT() *AddCellInfoRequest { + if m == nil { + return (*AddCellInfoRequest)(nil) + } + r := &AddCellInfoRequest{ + Name: m.Name, + CellInfo: m.CellInfo.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *AddCellInfoRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *AddCellInfoResponse) CloneVT() *AddCellInfoResponse { + if m == nil { + return (*AddCellInfoResponse)(nil) + } + r := &AddCellInfoResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *AddCellInfoResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *AddCellsAliasRequest) CloneVT() *AddCellsAliasRequest { + if m == nil { + return (*AddCellsAliasRequest)(nil) + } + r := &AddCellsAliasRequest{ + Name: m.Name, + } + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *AddCellsAliasRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *AddCellsAliasResponse) CloneVT() *AddCellsAliasResponse { + if m == nil { + return (*AddCellsAliasResponse)(nil) + } + r := &AddCellsAliasResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *AddCellsAliasResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ApplyRoutingRulesRequest) CloneVT() *ApplyRoutingRulesRequest { + if m == nil { + return (*ApplyRoutingRulesRequest)(nil) + } + r := &ApplyRoutingRulesRequest{ + RoutingRules: m.RoutingRules.CloneVT(), + SkipRebuild: m.SkipRebuild, + } + if rhs := m.RebuildCells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.RebuildCells = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ApplyRoutingRulesRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ApplyRoutingRulesResponse) CloneVT() *ApplyRoutingRulesResponse { + if m == nil { + return (*ApplyRoutingRulesResponse)(nil) + } + r := &ApplyRoutingRulesResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ApplyRoutingRulesResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ApplyShardRoutingRulesRequest) CloneVT() *ApplyShardRoutingRulesRequest { + if m == nil { + return (*ApplyShardRoutingRulesRequest)(nil) + } + r := &ApplyShardRoutingRulesRequest{ + ShardRoutingRules: m.ShardRoutingRules.CloneVT(), + SkipRebuild: m.SkipRebuild, + } + if rhs := m.RebuildCells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.RebuildCells = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ApplyShardRoutingRulesRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ApplyShardRoutingRulesResponse) CloneVT() *ApplyShardRoutingRulesResponse { + if m == nil { + return (*ApplyShardRoutingRulesResponse)(nil) + } + r := &ApplyShardRoutingRulesResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ApplyShardRoutingRulesResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ApplySchemaRequest) CloneVT() *ApplySchemaRequest { + if m == nil { + return (*ApplySchemaRequest)(nil) + } + r := &ApplySchemaRequest{ + Keyspace: m.Keyspace, + DdlStrategy: m.DdlStrategy, + MigrationContext: m.MigrationContext, + WaitReplicasTimeout: m.WaitReplicasTimeout.CloneVT(), + SkipPreflight: m.SkipPreflight, + CallerId: m.CallerId.CloneVT(), + BatchSize: m.BatchSize, + } + if rhs := m.Sql; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Sql = tmpContainer + } + if rhs := m.UuidList; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.UuidList = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ApplySchemaRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ApplySchemaResponse) CloneVT() *ApplySchemaResponse { + if m == nil { + return (*ApplySchemaResponse)(nil) + } + r := &ApplySchemaResponse{} + if rhs := m.UuidList; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.UuidList = tmpContainer + } + if rhs := m.RowsAffectedByShard; rhs != nil { + tmpContainer := make(map[string]uint64, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.RowsAffectedByShard = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ApplySchemaResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ApplyVSchemaRequest) CloneVT() *ApplyVSchemaRequest { + if m == nil { + return (*ApplyVSchemaRequest)(nil) + } + r := &ApplyVSchemaRequest{ + Keyspace: m.Keyspace, + SkipRebuild: m.SkipRebuild, + DryRun: m.DryRun, + VSchema: m.VSchema.CloneVT(), + Sql: m.Sql, + } + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ApplyVSchemaRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ApplyVSchemaResponse) CloneVT() *ApplyVSchemaResponse { + if m == nil { + return (*ApplyVSchemaResponse)(nil) + } + r := &ApplyVSchemaResponse{ + VSchema: m.VSchema.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ApplyVSchemaResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *BackupRequest) CloneVT() *BackupRequest { + if m == nil { + return (*BackupRequest)(nil) + } + r := &BackupRequest{ + TabletAlias: m.TabletAlias.CloneVT(), + AllowPrimary: m.AllowPrimary, + Concurrency: m.Concurrency, + IncrementalFromPos: m.IncrementalFromPos, + UpgradeSafe: m.UpgradeSafe, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BackupRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *BackupResponse) CloneVT() *BackupResponse { + if m == nil { + return (*BackupResponse)(nil) + } + r := &BackupResponse{ + TabletAlias: m.TabletAlias.CloneVT(), + Keyspace: m.Keyspace, + Shard: m.Shard, + Event: m.Event.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BackupResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *BackupShardRequest) CloneVT() *BackupShardRequest { + if m == nil { + return (*BackupShardRequest)(nil) + } + r := &BackupShardRequest{ + Keyspace: m.Keyspace, + Shard: m.Shard, + AllowPrimary: m.AllowPrimary, + Concurrency: m.Concurrency, + UpgradeSafe: m.UpgradeSafe, + IncrementalFromPos: m.IncrementalFromPos, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *BackupShardRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CancelSchemaMigrationRequest) CloneVT() *CancelSchemaMigrationRequest { + if m == nil { + return (*CancelSchemaMigrationRequest)(nil) + } + r := &CancelSchemaMigrationRequest{ + Keyspace: m.Keyspace, + Uuid: m.Uuid, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CancelSchemaMigrationRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CancelSchemaMigrationResponse) CloneVT() *CancelSchemaMigrationResponse { + if m == nil { + return (*CancelSchemaMigrationResponse)(nil) + } + r := &CancelSchemaMigrationResponse{} + if rhs := m.RowsAffectedByShard; rhs != nil { + tmpContainer := make(map[string]uint64, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.RowsAffectedByShard = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CancelSchemaMigrationResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ChangeTabletTypeRequest) CloneVT() *ChangeTabletTypeRequest { + if m == nil { + return (*ChangeTabletTypeRequest)(nil) + } + r := &ChangeTabletTypeRequest{ + TabletAlias: m.TabletAlias.CloneVT(), + DbType: m.DbType, + DryRun: m.DryRun, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ChangeTabletTypeRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ChangeTabletTypeResponse) CloneVT() *ChangeTabletTypeResponse { + if m == nil { + return (*ChangeTabletTypeResponse)(nil) + } + r := &ChangeTabletTypeResponse{ + BeforeTablet: m.BeforeTablet.CloneVT(), + AfterTablet: m.AfterTablet.CloneVT(), + WasDryRun: m.WasDryRun, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ChangeTabletTypeResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CleanupSchemaMigrationRequest) CloneVT() *CleanupSchemaMigrationRequest { + if m == nil { + return (*CleanupSchemaMigrationRequest)(nil) + } + r := &CleanupSchemaMigrationRequest{ + Keyspace: m.Keyspace, + Uuid: m.Uuid, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CleanupSchemaMigrationRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CleanupSchemaMigrationResponse) CloneVT() *CleanupSchemaMigrationResponse { + if m == nil { + return (*CleanupSchemaMigrationResponse)(nil) + } + r := &CleanupSchemaMigrationResponse{} + if rhs := m.RowsAffectedByShard; rhs != nil { + tmpContainer := make(map[string]uint64, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.RowsAffectedByShard = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CleanupSchemaMigrationResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CompleteSchemaMigrationRequest) CloneVT() *CompleteSchemaMigrationRequest { + if m == nil { + return (*CompleteSchemaMigrationRequest)(nil) + } + r := &CompleteSchemaMigrationRequest{ + Keyspace: m.Keyspace, + Uuid: m.Uuid, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CompleteSchemaMigrationRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CompleteSchemaMigrationResponse) CloneVT() *CompleteSchemaMigrationResponse { + if m == nil { + return (*CompleteSchemaMigrationResponse)(nil) + } + r := &CompleteSchemaMigrationResponse{} + if rhs := m.RowsAffectedByShard; rhs != nil { + tmpContainer := make(map[string]uint64, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.RowsAffectedByShard = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CompleteSchemaMigrationResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CreateKeyspaceRequest) CloneVT() *CreateKeyspaceRequest { + if m == nil { + return (*CreateKeyspaceRequest)(nil) + } + r := &CreateKeyspaceRequest{ + Name: m.Name, + Force: m.Force, + AllowEmptyVSchema: m.AllowEmptyVSchema, + Type: m.Type, + BaseKeyspace: m.BaseKeyspace, + SnapshotTime: m.SnapshotTime.CloneVT(), + DurabilityPolicy: m.DurabilityPolicy, + SidecarDbName: m.SidecarDbName, + } + if rhs := m.ServedFroms; rhs != nil { + tmpContainer := make([]*topodata.Keyspace_ServedFrom, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ServedFroms = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CreateKeyspaceRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CreateKeyspaceResponse) CloneVT() *CreateKeyspaceResponse { + if m == nil { + return (*CreateKeyspaceResponse)(nil) + } + r := &CreateKeyspaceResponse{ + Keyspace: m.Keyspace.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CreateKeyspaceResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CreateShardRequest) CloneVT() *CreateShardRequest { + if m == nil { + return (*CreateShardRequest)(nil) + } + r := &CreateShardRequest{ + Keyspace: m.Keyspace, + ShardName: m.ShardName, + Force: m.Force, + IncludeParent: m.IncludeParent, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CreateShardRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CreateShardResponse) CloneVT() *CreateShardResponse { + if m == nil { + return (*CreateShardResponse)(nil) + } + r := &CreateShardResponse{ + Keyspace: m.Keyspace.CloneVT(), + Shard: m.Shard.CloneVT(), + ShardAlreadyExists: m.ShardAlreadyExists, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CreateShardResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DeleteCellInfoRequest) CloneVT() *DeleteCellInfoRequest { + if m == nil { + return (*DeleteCellInfoRequest)(nil) + } + r := &DeleteCellInfoRequest{ + Name: m.Name, + Force: m.Force, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DeleteCellInfoRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DeleteCellInfoResponse) CloneVT() *DeleteCellInfoResponse { + if m == nil { + return (*DeleteCellInfoResponse)(nil) + } + r := &DeleteCellInfoResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DeleteCellInfoResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DeleteCellsAliasRequest) CloneVT() *DeleteCellsAliasRequest { + if m == nil { + return (*DeleteCellsAliasRequest)(nil) + } + r := &DeleteCellsAliasRequest{ + Name: m.Name, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DeleteCellsAliasRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DeleteCellsAliasResponse) CloneVT() *DeleteCellsAliasResponse { + if m == nil { + return (*DeleteCellsAliasResponse)(nil) + } + r := &DeleteCellsAliasResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DeleteCellsAliasResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DeleteKeyspaceRequest) CloneVT() *DeleteKeyspaceRequest { + if m == nil { + return (*DeleteKeyspaceRequest)(nil) + } + r := &DeleteKeyspaceRequest{ + Keyspace: m.Keyspace, + Recursive: m.Recursive, + Force: m.Force, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DeleteKeyspaceRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DeleteKeyspaceResponse) CloneVT() *DeleteKeyspaceResponse { + if m == nil { + return (*DeleteKeyspaceResponse)(nil) + } + r := &DeleteKeyspaceResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DeleteKeyspaceResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DeleteShardsRequest) CloneVT() *DeleteShardsRequest { + if m == nil { + return (*DeleteShardsRequest)(nil) + } + r := &DeleteShardsRequest{ + Recursive: m.Recursive, + EvenIfServing: m.EvenIfServing, + Force: m.Force, + } + if rhs := m.Shards; rhs != nil { + tmpContainer := make([]*Shard, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Shards = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DeleteShardsRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DeleteShardsResponse) CloneVT() *DeleteShardsResponse { + if m == nil { + return (*DeleteShardsResponse)(nil) + } + r := &DeleteShardsResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DeleteShardsResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DeleteSrvVSchemaRequest) CloneVT() *DeleteSrvVSchemaRequest { + if m == nil { + return (*DeleteSrvVSchemaRequest)(nil) + } + r := &DeleteSrvVSchemaRequest{ + Cell: m.Cell, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DeleteSrvVSchemaRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DeleteSrvVSchemaResponse) CloneVT() *DeleteSrvVSchemaResponse { + if m == nil { + return (*DeleteSrvVSchemaResponse)(nil) + } + r := &DeleteSrvVSchemaResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DeleteSrvVSchemaResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DeleteTabletsRequest) CloneVT() *DeleteTabletsRequest { + if m == nil { + return (*DeleteTabletsRequest)(nil) + } + r := &DeleteTabletsRequest{ + AllowPrimary: m.AllowPrimary, + } + if rhs := m.TabletAliases; rhs != nil { + tmpContainer := make([]*topodata.TabletAlias, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.TabletAliases = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DeleteTabletsRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *DeleteTabletsResponse) CloneVT() *DeleteTabletsResponse { + if m == nil { + return (*DeleteTabletsResponse)(nil) + } + r := &DeleteTabletsResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *DeleteTabletsResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *EmergencyReparentShardRequest) CloneVT() *EmergencyReparentShardRequest { + if m == nil { + return (*EmergencyReparentShardRequest)(nil) + } + r := &EmergencyReparentShardRequest{ + Keyspace: m.Keyspace, + Shard: m.Shard, + NewPrimary: m.NewPrimary.CloneVT(), + WaitReplicasTimeout: m.WaitReplicasTimeout.CloneVT(), + PreventCrossCellPromotion: m.PreventCrossCellPromotion, + WaitForAllTablets: m.WaitForAllTablets, + } + if rhs := m.IgnoreReplicas; rhs != nil { + tmpContainer := make([]*topodata.TabletAlias, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.IgnoreReplicas = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *EmergencyReparentShardRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *EmergencyReparentShardResponse) CloneVT() *EmergencyReparentShardResponse { + if m == nil { + return (*EmergencyReparentShardResponse)(nil) + } + r := &EmergencyReparentShardResponse{ + Keyspace: m.Keyspace, + Shard: m.Shard, + PromotedPrimary: m.PromotedPrimary.CloneVT(), + } + if rhs := m.Events; rhs != nil { + tmpContainer := make([]*logutil.Event, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Events = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *EmergencyReparentShardResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteFetchAsAppRequest) CloneVT() *ExecuteFetchAsAppRequest { + if m == nil { + return (*ExecuteFetchAsAppRequest)(nil) + } + r := &ExecuteFetchAsAppRequest{ + TabletAlias: m.TabletAlias.CloneVT(), + Query: m.Query, + MaxRows: m.MaxRows, + UsePool: m.UsePool, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteFetchAsAppRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteFetchAsAppResponse) CloneVT() *ExecuteFetchAsAppResponse { + if m == nil { + return (*ExecuteFetchAsAppResponse)(nil) + } + r := &ExecuteFetchAsAppResponse{ + Result: m.Result.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteFetchAsAppResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteFetchAsDBARequest) CloneVT() *ExecuteFetchAsDBARequest { + if m == nil { + return (*ExecuteFetchAsDBARequest)(nil) + } + r := &ExecuteFetchAsDBARequest{ + TabletAlias: m.TabletAlias.CloneVT(), + Query: m.Query, + MaxRows: m.MaxRows, + DisableBinlogs: m.DisableBinlogs, + ReloadSchema: m.ReloadSchema, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteFetchAsDBARequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteFetchAsDBAResponse) CloneVT() *ExecuteFetchAsDBAResponse { + if m == nil { + return (*ExecuteFetchAsDBAResponse)(nil) + } + r := &ExecuteFetchAsDBAResponse{ + Result: m.Result.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteFetchAsDBAResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteHookRequest) CloneVT() *ExecuteHookRequest { + if m == nil { + return (*ExecuteHookRequest)(nil) + } + r := &ExecuteHookRequest{ + TabletAlias: m.TabletAlias.CloneVT(), + TabletHookRequest: m.TabletHookRequest.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteHookRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteHookResponse) CloneVT() *ExecuteHookResponse { + if m == nil { + return (*ExecuteHookResponse)(nil) + } + r := &ExecuteHookResponse{ + HookResult: m.HookResult.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteHookResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *FindAllShardsInKeyspaceRequest) CloneVT() *FindAllShardsInKeyspaceRequest { + if m == nil { + return (*FindAllShardsInKeyspaceRequest)(nil) + } + r := &FindAllShardsInKeyspaceRequest{ + Keyspace: m.Keyspace, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *FindAllShardsInKeyspaceRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *FindAllShardsInKeyspaceResponse) CloneVT() *FindAllShardsInKeyspaceResponse { + if m == nil { + return (*FindAllShardsInKeyspaceResponse)(nil) + } + r := &FindAllShardsInKeyspaceResponse{} + if rhs := m.Shards; rhs != nil { + tmpContainer := make(map[string]*Shard, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Shards = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *FindAllShardsInKeyspaceResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetBackupsRequest) CloneVT() *GetBackupsRequest { + if m == nil { + return (*GetBackupsRequest)(nil) + } + r := &GetBackupsRequest{ + Keyspace: m.Keyspace, + Shard: m.Shard, + Limit: m.Limit, + Detailed: m.Detailed, + DetailedLimit: m.DetailedLimit, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetBackupsRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetBackupsResponse) CloneVT() *GetBackupsResponse { + if m == nil { + return (*GetBackupsResponse)(nil) + } + r := &GetBackupsResponse{} + if rhs := m.Backups; rhs != nil { + tmpContainer := make([]*mysqlctl.BackupInfo, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Backups = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetBackupsResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetCellInfoRequest) CloneVT() *GetCellInfoRequest { + if m == nil { + return (*GetCellInfoRequest)(nil) + } + r := &GetCellInfoRequest{ + Cell: m.Cell, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetCellInfoRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetCellInfoResponse) CloneVT() *GetCellInfoResponse { + if m == nil { + return (*GetCellInfoResponse)(nil) + } + r := &GetCellInfoResponse{ + CellInfo: m.CellInfo.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetCellInfoResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetCellInfoNamesRequest) CloneVT() *GetCellInfoNamesRequest { + if m == nil { + return (*GetCellInfoNamesRequest)(nil) + } + r := &GetCellInfoNamesRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetCellInfoNamesRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetCellInfoNamesResponse) CloneVT() *GetCellInfoNamesResponse { + if m == nil { + return (*GetCellInfoNamesResponse)(nil) + } + r := &GetCellInfoNamesResponse{} + if rhs := m.Names; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Names = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetCellInfoNamesResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetCellsAliasesRequest) CloneVT() *GetCellsAliasesRequest { + if m == nil { + return (*GetCellsAliasesRequest)(nil) + } + r := &GetCellsAliasesRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetCellsAliasesRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetCellsAliasesResponse) CloneVT() *GetCellsAliasesResponse { + if m == nil { + return (*GetCellsAliasesResponse)(nil) + } + r := &GetCellsAliasesResponse{} + if rhs := m.Aliases; rhs != nil { + tmpContainer := make(map[string]*topodata.CellsAlias, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Aliases = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetCellsAliasesResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetFullStatusRequest) CloneVT() *GetFullStatusRequest { + if m == nil { + return (*GetFullStatusRequest)(nil) + } + r := &GetFullStatusRequest{ + TabletAlias: m.TabletAlias.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetFullStatusRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetFullStatusResponse) CloneVT() *GetFullStatusResponse { + if m == nil { + return (*GetFullStatusResponse)(nil) + } + r := &GetFullStatusResponse{ + Status: m.Status.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetFullStatusResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetKeyspacesRequest) CloneVT() *GetKeyspacesRequest { + if m == nil { + return (*GetKeyspacesRequest)(nil) + } + r := &GetKeyspacesRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetKeyspacesRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetKeyspacesResponse) CloneVT() *GetKeyspacesResponse { + if m == nil { + return (*GetKeyspacesResponse)(nil) + } + r := &GetKeyspacesResponse{} + if rhs := m.Keyspaces; rhs != nil { + tmpContainer := make([]*Keyspace, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Keyspaces = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetKeyspacesResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetKeyspaceRequest) CloneVT() *GetKeyspaceRequest { + if m == nil { + return (*GetKeyspaceRequest)(nil) + } + r := &GetKeyspaceRequest{ + Keyspace: m.Keyspace, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetKeyspaceRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetKeyspaceResponse) CloneVT() *GetKeyspaceResponse { + if m == nil { + return (*GetKeyspaceResponse)(nil) + } + r := &GetKeyspaceResponse{ + Keyspace: m.Keyspace.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetKeyspaceResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetPermissionsRequest) CloneVT() *GetPermissionsRequest { + if m == nil { + return (*GetPermissionsRequest)(nil) + } + r := &GetPermissionsRequest{ + TabletAlias: m.TabletAlias.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetPermissionsRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetPermissionsResponse) CloneVT() *GetPermissionsResponse { + if m == nil { + return (*GetPermissionsResponse)(nil) + } + r := &GetPermissionsResponse{ + Permissions: m.Permissions.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetPermissionsResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetRoutingRulesRequest) CloneVT() *GetRoutingRulesRequest { + if m == nil { + return (*GetRoutingRulesRequest)(nil) + } + r := &GetRoutingRulesRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetRoutingRulesRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetRoutingRulesResponse) CloneVT() *GetRoutingRulesResponse { + if m == nil { + return (*GetRoutingRulesResponse)(nil) + } + r := &GetRoutingRulesResponse{ + RoutingRules: m.RoutingRules.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetRoutingRulesResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSchemaRequest) CloneVT() *GetSchemaRequest { + if m == nil { + return (*GetSchemaRequest)(nil) + } + r := &GetSchemaRequest{ + TabletAlias: m.TabletAlias.CloneVT(), + IncludeViews: m.IncludeViews, + TableNamesOnly: m.TableNamesOnly, + TableSizesOnly: m.TableSizesOnly, + TableSchemaOnly: m.TableSchemaOnly, + } + if rhs := m.Tables; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Tables = tmpContainer + } + if rhs := m.ExcludeTables; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ExcludeTables = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSchemaRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSchemaResponse) CloneVT() *GetSchemaResponse { + if m == nil { + return (*GetSchemaResponse)(nil) + } + r := &GetSchemaResponse{ + Schema: m.Schema.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSchemaResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSchemaMigrationsRequest) CloneVT() *GetSchemaMigrationsRequest { + if m == nil { + return (*GetSchemaMigrationsRequest)(nil) + } + r := &GetSchemaMigrationsRequest{ + Keyspace: m.Keyspace, + Uuid: m.Uuid, + MigrationContext: m.MigrationContext, + Status: m.Status, + Recent: m.Recent.CloneVT(), + Order: m.Order, + Limit: m.Limit, + Skip: m.Skip, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSchemaMigrationsRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSchemaMigrationsResponse) CloneVT() *GetSchemaMigrationsResponse { + if m == nil { + return (*GetSchemaMigrationsResponse)(nil) + } + r := &GetSchemaMigrationsResponse{} + if rhs := m.Migrations; rhs != nil { + tmpContainer := make([]*SchemaMigration, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Migrations = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSchemaMigrationsResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetShardRequest) CloneVT() *GetShardRequest { + if m == nil { + return (*GetShardRequest)(nil) + } + r := &GetShardRequest{ + Keyspace: m.Keyspace, + ShardName: m.ShardName, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetShardRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetShardResponse) CloneVT() *GetShardResponse { + if m == nil { + return (*GetShardResponse)(nil) + } + r := &GetShardResponse{ + Shard: m.Shard.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetShardResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetShardRoutingRulesRequest) CloneVT() *GetShardRoutingRulesRequest { + if m == nil { + return (*GetShardRoutingRulesRequest)(nil) + } + r := &GetShardRoutingRulesRequest{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetShardRoutingRulesRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetShardRoutingRulesResponse) CloneVT() *GetShardRoutingRulesResponse { + if m == nil { + return (*GetShardRoutingRulesResponse)(nil) + } + r := &GetShardRoutingRulesResponse{ + ShardRoutingRules: m.ShardRoutingRules.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetShardRoutingRulesResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSrvKeyspaceNamesRequest) CloneVT() *GetSrvKeyspaceNamesRequest { + if m == nil { + return (*GetSrvKeyspaceNamesRequest)(nil) + } + r := &GetSrvKeyspaceNamesRequest{} + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSrvKeyspaceNamesRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSrvKeyspaceNamesResponse_NameList) CloneVT() *GetSrvKeyspaceNamesResponse_NameList { + if m == nil { + return (*GetSrvKeyspaceNamesResponse_NameList)(nil) + } + r := &GetSrvKeyspaceNamesResponse_NameList{} + if rhs := m.Names; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Names = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSrvKeyspaceNamesResponse_NameList) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSrvKeyspaceNamesResponse) CloneVT() *GetSrvKeyspaceNamesResponse { + if m == nil { + return (*GetSrvKeyspaceNamesResponse)(nil) + } + r := &GetSrvKeyspaceNamesResponse{} + if rhs := m.Names; rhs != nil { + tmpContainer := make(map[string]*GetSrvKeyspaceNamesResponse_NameList, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Names = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSrvKeyspaceNamesResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSrvKeyspacesRequest) CloneVT() *GetSrvKeyspacesRequest { + if m == nil { + return (*GetSrvKeyspacesRequest)(nil) + } + r := &GetSrvKeyspacesRequest{ + Keyspace: m.Keyspace, + } + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSrvKeyspacesRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSrvKeyspacesResponse) CloneVT() *GetSrvKeyspacesResponse { + if m == nil { + return (*GetSrvKeyspacesResponse)(nil) + } + r := &GetSrvKeyspacesResponse{} + if rhs := m.SrvKeyspaces; rhs != nil { + tmpContainer := make(map[string]*topodata.SrvKeyspace, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.SrvKeyspaces = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSrvKeyspacesResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UpdateThrottlerConfigRequest) CloneVT() *UpdateThrottlerConfigRequest { + if m == nil { + return (*UpdateThrottlerConfigRequest)(nil) + } + r := &UpdateThrottlerConfigRequest{ + Keyspace: m.Keyspace, + Enable: m.Enable, + Disable: m.Disable, + Threshold: m.Threshold, + CustomQuery: m.CustomQuery, + CustomQuerySet: m.CustomQuerySet, + CheckAsCheckSelf: m.CheckAsCheckSelf, + CheckAsCheckShard: m.CheckAsCheckShard, + ThrottledApp: m.ThrottledApp.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UpdateThrottlerConfigRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UpdateThrottlerConfigResponse) CloneVT() *UpdateThrottlerConfigResponse { + if m == nil { + return (*UpdateThrottlerConfigResponse)(nil) + } + r := &UpdateThrottlerConfigResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UpdateThrottlerConfigResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSrvVSchemaRequest) CloneVT() *GetSrvVSchemaRequest { + if m == nil { + return (*GetSrvVSchemaRequest)(nil) + } + r := &GetSrvVSchemaRequest{ + Cell: m.Cell, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSrvVSchemaRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSrvVSchemaResponse) CloneVT() *GetSrvVSchemaResponse { + if m == nil { + return (*GetSrvVSchemaResponse)(nil) + } + r := &GetSrvVSchemaResponse{ + SrvVSchema: m.SrvVSchema.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSrvVSchemaResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSrvVSchemasRequest) CloneVT() *GetSrvVSchemasRequest { + if m == nil { + return (*GetSrvVSchemasRequest)(nil) + } + r := &GetSrvVSchemasRequest{} + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSrvVSchemasRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetSrvVSchemasResponse) CloneVT() *GetSrvVSchemasResponse { + if m == nil { + return (*GetSrvVSchemasResponse)(nil) + } + r := &GetSrvVSchemasResponse{} + if rhs := m.SrvVSchemas; rhs != nil { + tmpContainer := make(map[string]*vschema.SrvVSchema, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.SrvVSchemas = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetSrvVSchemasResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetTabletRequest) CloneVT() *GetTabletRequest { + if m == nil { + return (*GetTabletRequest)(nil) + } + r := &GetTabletRequest{ + TabletAlias: m.TabletAlias.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetTabletRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetTabletResponse) CloneVT() *GetTabletResponse { + if m == nil { + return (*GetTabletResponse)(nil) + } + r := &GetTabletResponse{ + Tablet: m.Tablet.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetTabletResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetTabletsRequest) CloneVT() *GetTabletsRequest { + if m == nil { + return (*GetTabletsRequest)(nil) + } + r := &GetTabletsRequest{ + Keyspace: m.Keyspace, + Shard: m.Shard, + Strict: m.Strict, + TabletType: m.TabletType, + } + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if rhs := m.TabletAliases; rhs != nil { + tmpContainer := make([]*topodata.TabletAlias, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.TabletAliases = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetTabletsRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetTabletsResponse) CloneVT() *GetTabletsResponse { + if m == nil { + return (*GetTabletsResponse)(nil) + } + r := &GetTabletsResponse{} + if rhs := m.Tablets; rhs != nil { + tmpContainer := make([]*topodata.Tablet, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Tablets = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetTabletsResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetTopologyPathRequest) CloneVT() *GetTopologyPathRequest { + if m == nil { + return (*GetTopologyPathRequest)(nil) + } + r := &GetTopologyPathRequest{ + Path: m.Path, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetTopologyPathRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetTopologyPathResponse) CloneVT() *GetTopologyPathResponse { + if m == nil { + return (*GetTopologyPathResponse)(nil) + } + r := &GetTopologyPathResponse{ + Cell: m.Cell.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetTopologyPathResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *TopologyCell) CloneVT() *TopologyCell { + if m == nil { + return (*TopologyCell)(nil) + } + r := &TopologyCell{ + Name: m.Name, + Path: m.Path, + Data: m.Data, + } + if rhs := m.Children; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Children = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *TopologyCell) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetVSchemaRequest) CloneVT() *GetVSchemaRequest { + if m == nil { + return (*GetVSchemaRequest)(nil) + } + r := &GetVSchemaRequest{ + Keyspace: m.Keyspace, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetVSchemaRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetVersionRequest) CloneVT() *GetVersionRequest { + if m == nil { + return (*GetVersionRequest)(nil) + } + r := &GetVersionRequest{ + TabletAlias: m.TabletAlias.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetVersionRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetVersionResponse) CloneVT() *GetVersionResponse { + if m == nil { + return (*GetVersionResponse)(nil) + } + r := &GetVersionResponse{ + Version: m.Version, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetVersionResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetVSchemaResponse) CloneVT() *GetVSchemaResponse { + if m == nil { + return (*GetVSchemaResponse)(nil) + } + r := &GetVSchemaResponse{ + VSchema: m.VSchema.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetVSchemaResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetWorkflowsRequest) CloneVT() *GetWorkflowsRequest { + if m == nil { + return (*GetWorkflowsRequest)(nil) + } + r := &GetWorkflowsRequest{ + Keyspace: m.Keyspace, + ActiveOnly: m.ActiveOnly, + NameOnly: m.NameOnly, + Workflow: m.Workflow, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetWorkflowsRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *GetWorkflowsResponse) CloneVT() *GetWorkflowsResponse { + if m == nil { + return (*GetWorkflowsResponse)(nil) + } + r := &GetWorkflowsResponse{} + if rhs := m.Workflows; rhs != nil { + tmpContainer := make([]*Workflow, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Workflows = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *GetWorkflowsResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *InitShardPrimaryRequest) CloneVT() *InitShardPrimaryRequest { + if m == nil { + return (*InitShardPrimaryRequest)(nil) + } + r := &InitShardPrimaryRequest{ + Keyspace: m.Keyspace, + Shard: m.Shard, + PrimaryElectTabletAlias: m.PrimaryElectTabletAlias.CloneVT(), + Force: m.Force, + WaitReplicasTimeout: m.WaitReplicasTimeout.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *InitShardPrimaryRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *InitShardPrimaryResponse) CloneVT() *InitShardPrimaryResponse { + if m == nil { + return (*InitShardPrimaryResponse)(nil) + } + r := &InitShardPrimaryResponse{} + if rhs := m.Events; rhs != nil { + tmpContainer := make([]*logutil.Event, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Events = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *InitShardPrimaryResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *LaunchSchemaMigrationRequest) CloneVT() *LaunchSchemaMigrationRequest { + if m == nil { + return (*LaunchSchemaMigrationRequest)(nil) + } + r := &LaunchSchemaMigrationRequest{ + Keyspace: m.Keyspace, + Uuid: m.Uuid, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *LaunchSchemaMigrationRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *LaunchSchemaMigrationResponse) CloneVT() *LaunchSchemaMigrationResponse { + if m == nil { + return (*LaunchSchemaMigrationResponse)(nil) + } + r := &LaunchSchemaMigrationResponse{} + if rhs := m.RowsAffectedByShard; rhs != nil { + tmpContainer := make(map[string]uint64, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.RowsAffectedByShard = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *LaunchSchemaMigrationResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *MoveTablesCreateRequest) CloneVT() *MoveTablesCreateRequest { + if m == nil { + return (*MoveTablesCreateRequest)(nil) + } + r := &MoveTablesCreateRequest{ + Workflow: m.Workflow, + SourceKeyspace: m.SourceKeyspace, + TargetKeyspace: m.TargetKeyspace, + TabletSelectionPreference: m.TabletSelectionPreference, + AllTables: m.AllTables, + ExternalClusterName: m.ExternalClusterName, + SourceTimeZone: m.SourceTimeZone, + OnDdl: m.OnDdl, + StopAfterCopy: m.StopAfterCopy, + DropForeignKeys: m.DropForeignKeys, + DeferSecondaryKeys: m.DeferSecondaryKeys, + AutoStart: m.AutoStart, + NoRoutingRules: m.NoRoutingRules, + } + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if rhs := m.TabletTypes; rhs != nil { + tmpContainer := make([]topodata.TabletType, len(rhs)) + copy(tmpContainer, rhs) + r.TabletTypes = tmpContainer + } + if rhs := m.SourceShards; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.SourceShards = tmpContainer + } + if rhs := m.IncludeTables; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.IncludeTables = tmpContainer + } + if rhs := m.ExcludeTables; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ExcludeTables = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *MoveTablesCreateRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *MoveTablesCreateResponse_TabletInfo) CloneVT() *MoveTablesCreateResponse_TabletInfo { + if m == nil { + return (*MoveTablesCreateResponse_TabletInfo)(nil) + } + r := &MoveTablesCreateResponse_TabletInfo{ + Tablet: m.Tablet.CloneVT(), + Created: m.Created, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *MoveTablesCreateResponse_TabletInfo) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *MoveTablesCreateResponse) CloneVT() *MoveTablesCreateResponse { + if m == nil { + return (*MoveTablesCreateResponse)(nil) + } + r := &MoveTablesCreateResponse{ + Summary: m.Summary, + } + if rhs := m.Details; rhs != nil { + tmpContainer := make([]*MoveTablesCreateResponse_TabletInfo, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Details = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *MoveTablesCreateResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *MoveTablesCompleteRequest) CloneVT() *MoveTablesCompleteRequest { + if m == nil { + return (*MoveTablesCompleteRequest)(nil) + } + r := &MoveTablesCompleteRequest{ + Workflow: m.Workflow, + TargetKeyspace: m.TargetKeyspace, + KeepData: m.KeepData, + KeepRoutingRules: m.KeepRoutingRules, + RenameTables: m.RenameTables, + DryRun: m.DryRun, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *MoveTablesCompleteRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *MoveTablesCompleteResponse) CloneVT() *MoveTablesCompleteResponse { + if m == nil { + return (*MoveTablesCompleteResponse)(nil) + } + r := &MoveTablesCompleteResponse{ + Summary: m.Summary, + } + if rhs := m.DryRunResults; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.DryRunResults = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *MoveTablesCompleteResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PingTabletRequest) CloneVT() *PingTabletRequest { + if m == nil { + return (*PingTabletRequest)(nil) + } + r := &PingTabletRequest{ + TabletAlias: m.TabletAlias.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PingTabletRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PingTabletResponse) CloneVT() *PingTabletResponse { + if m == nil { + return (*PingTabletResponse)(nil) + } + r := &PingTabletResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PingTabletResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PlannedReparentShardRequest) CloneVT() *PlannedReparentShardRequest { + if m == nil { + return (*PlannedReparentShardRequest)(nil) + } + r := &PlannedReparentShardRequest{ + Keyspace: m.Keyspace, + Shard: m.Shard, + NewPrimary: m.NewPrimary.CloneVT(), + AvoidPrimary: m.AvoidPrimary.CloneVT(), + WaitReplicasTimeout: m.WaitReplicasTimeout.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PlannedReparentShardRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PlannedReparentShardResponse) CloneVT() *PlannedReparentShardResponse { + if m == nil { + return (*PlannedReparentShardResponse)(nil) + } + r := &PlannedReparentShardResponse{ + Keyspace: m.Keyspace, + Shard: m.Shard, + PromotedPrimary: m.PromotedPrimary.CloneVT(), + } + if rhs := m.Events; rhs != nil { + tmpContainer := make([]*logutil.Event, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Events = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PlannedReparentShardResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RebuildKeyspaceGraphRequest) CloneVT() *RebuildKeyspaceGraphRequest { + if m == nil { + return (*RebuildKeyspaceGraphRequest)(nil) + } + r := &RebuildKeyspaceGraphRequest{ + Keyspace: m.Keyspace, + AllowPartial: m.AllowPartial, + } + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RebuildKeyspaceGraphRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RebuildKeyspaceGraphResponse) CloneVT() *RebuildKeyspaceGraphResponse { + if m == nil { + return (*RebuildKeyspaceGraphResponse)(nil) + } + r := &RebuildKeyspaceGraphResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RebuildKeyspaceGraphResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RebuildVSchemaGraphRequest) CloneVT() *RebuildVSchemaGraphRequest { + if m == nil { + return (*RebuildVSchemaGraphRequest)(nil) + } + r := &RebuildVSchemaGraphRequest{} + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RebuildVSchemaGraphRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RebuildVSchemaGraphResponse) CloneVT() *RebuildVSchemaGraphResponse { + if m == nil { + return (*RebuildVSchemaGraphResponse)(nil) + } + r := &RebuildVSchemaGraphResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RebuildVSchemaGraphResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RefreshStateRequest) CloneVT() *RefreshStateRequest { + if m == nil { + return (*RefreshStateRequest)(nil) + } + r := &RefreshStateRequest{ + TabletAlias: m.TabletAlias.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RefreshStateRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RefreshStateResponse) CloneVT() *RefreshStateResponse { + if m == nil { + return (*RefreshStateResponse)(nil) + } + r := &RefreshStateResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RefreshStateResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RefreshStateByShardRequest) CloneVT() *RefreshStateByShardRequest { + if m == nil { + return (*RefreshStateByShardRequest)(nil) + } + r := &RefreshStateByShardRequest{ + Keyspace: m.Keyspace, + Shard: m.Shard, + } + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RefreshStateByShardRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RefreshStateByShardResponse) CloneVT() *RefreshStateByShardResponse { + if m == nil { + return (*RefreshStateByShardResponse)(nil) + } + r := &RefreshStateByShardResponse{ + IsPartialRefresh: m.IsPartialRefresh, + PartialRefreshDetails: m.PartialRefreshDetails, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RefreshStateByShardResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReloadSchemaRequest) CloneVT() *ReloadSchemaRequest { + if m == nil { + return (*ReloadSchemaRequest)(nil) + } + r := &ReloadSchemaRequest{ + TabletAlias: m.TabletAlias.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReloadSchemaRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReloadSchemaResponse) CloneVT() *ReloadSchemaResponse { + if m == nil { + return (*ReloadSchemaResponse)(nil) + } + r := &ReloadSchemaResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReloadSchemaResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReloadSchemaKeyspaceRequest) CloneVT() *ReloadSchemaKeyspaceRequest { + if m == nil { + return (*ReloadSchemaKeyspaceRequest)(nil) + } + r := &ReloadSchemaKeyspaceRequest{ + Keyspace: m.Keyspace, + WaitPosition: m.WaitPosition, + IncludePrimary: m.IncludePrimary, + Concurrency: m.Concurrency, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReloadSchemaKeyspaceRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReloadSchemaKeyspaceResponse) CloneVT() *ReloadSchemaKeyspaceResponse { + if m == nil { + return (*ReloadSchemaKeyspaceResponse)(nil) + } + r := &ReloadSchemaKeyspaceResponse{} + if rhs := m.Events; rhs != nil { + tmpContainer := make([]*logutil.Event, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Events = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReloadSchemaKeyspaceResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReloadSchemaShardRequest) CloneVT() *ReloadSchemaShardRequest { + if m == nil { + return (*ReloadSchemaShardRequest)(nil) + } + r := &ReloadSchemaShardRequest{ + Keyspace: m.Keyspace, + Shard: m.Shard, + WaitPosition: m.WaitPosition, + IncludePrimary: m.IncludePrimary, + Concurrency: m.Concurrency, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReloadSchemaShardRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReloadSchemaShardResponse) CloneVT() *ReloadSchemaShardResponse { + if m == nil { + return (*ReloadSchemaShardResponse)(nil) + } + r := &ReloadSchemaShardResponse{} + if rhs := m.Events; rhs != nil { + tmpContainer := make([]*logutil.Event, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Events = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReloadSchemaShardResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RemoveBackupRequest) CloneVT() *RemoveBackupRequest { + if m == nil { + return (*RemoveBackupRequest)(nil) + } + r := &RemoveBackupRequest{ + Keyspace: m.Keyspace, + Shard: m.Shard, + Name: m.Name, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RemoveBackupRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RemoveBackupResponse) CloneVT() *RemoveBackupResponse { + if m == nil { + return (*RemoveBackupResponse)(nil) + } + r := &RemoveBackupResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RemoveBackupResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RemoveKeyspaceCellRequest) CloneVT() *RemoveKeyspaceCellRequest { + if m == nil { + return (*RemoveKeyspaceCellRequest)(nil) + } + r := &RemoveKeyspaceCellRequest{ + Keyspace: m.Keyspace, + Cell: m.Cell, + Force: m.Force, + Recursive: m.Recursive, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RemoveKeyspaceCellRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RemoveKeyspaceCellResponse) CloneVT() *RemoveKeyspaceCellResponse { + if m == nil { + return (*RemoveKeyspaceCellResponse)(nil) + } + r := &RemoveKeyspaceCellResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RemoveKeyspaceCellResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RemoveShardCellRequest) CloneVT() *RemoveShardCellRequest { + if m == nil { + return (*RemoveShardCellRequest)(nil) + } + r := &RemoveShardCellRequest{ + Keyspace: m.Keyspace, + ShardName: m.ShardName, + Cell: m.Cell, + Force: m.Force, + Recursive: m.Recursive, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RemoveShardCellRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RemoveShardCellResponse) CloneVT() *RemoveShardCellResponse { + if m == nil { + return (*RemoveShardCellResponse)(nil) + } + r := &RemoveShardCellResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RemoveShardCellResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReparentTabletRequest) CloneVT() *ReparentTabletRequest { + if m == nil { + return (*ReparentTabletRequest)(nil) + } + r := &ReparentTabletRequest{ + Tablet: m.Tablet.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReparentTabletRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReparentTabletResponse) CloneVT() *ReparentTabletResponse { + if m == nil { + return (*ReparentTabletResponse)(nil) + } + r := &ReparentTabletResponse{ + Keyspace: m.Keyspace, + Shard: m.Shard, + Primary: m.Primary.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReparentTabletResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RestoreFromBackupRequest) CloneVT() *RestoreFromBackupRequest { + if m == nil { + return (*RestoreFromBackupRequest)(nil) + } + r := &RestoreFromBackupRequest{ + TabletAlias: m.TabletAlias.CloneVT(), + BackupTime: m.BackupTime.CloneVT(), + RestoreToPos: m.RestoreToPos, + DryRun: m.DryRun, + RestoreToTimestamp: m.RestoreToTimestamp.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RestoreFromBackupRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RestoreFromBackupResponse) CloneVT() *RestoreFromBackupResponse { + if m == nil { + return (*RestoreFromBackupResponse)(nil) + } + r := &RestoreFromBackupResponse{ + TabletAlias: m.TabletAlias.CloneVT(), + Keyspace: m.Keyspace, + Shard: m.Shard, + Event: m.Event.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RestoreFromBackupResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RetrySchemaMigrationRequest) CloneVT() *RetrySchemaMigrationRequest { + if m == nil { + return (*RetrySchemaMigrationRequest)(nil) + } + r := &RetrySchemaMigrationRequest{ + Keyspace: m.Keyspace, + Uuid: m.Uuid, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RetrySchemaMigrationRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RetrySchemaMigrationResponse) CloneVT() *RetrySchemaMigrationResponse { + if m == nil { + return (*RetrySchemaMigrationResponse)(nil) + } + r := &RetrySchemaMigrationResponse{} + if rhs := m.RowsAffectedByShard; rhs != nil { + tmpContainer := make(map[string]uint64, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.RowsAffectedByShard = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RetrySchemaMigrationResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RunHealthCheckRequest) CloneVT() *RunHealthCheckRequest { + if m == nil { + return (*RunHealthCheckRequest)(nil) + } + r := &RunHealthCheckRequest{ + TabletAlias: m.TabletAlias.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RunHealthCheckRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RunHealthCheckResponse) CloneVT() *RunHealthCheckResponse { + if m == nil { + return (*RunHealthCheckResponse)(nil) + } + r := &RunHealthCheckResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RunHealthCheckResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetKeyspaceDurabilityPolicyRequest) CloneVT() *SetKeyspaceDurabilityPolicyRequest { + if m == nil { + return (*SetKeyspaceDurabilityPolicyRequest)(nil) + } + r := &SetKeyspaceDurabilityPolicyRequest{ + Keyspace: m.Keyspace, + DurabilityPolicy: m.DurabilityPolicy, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetKeyspaceDurabilityPolicyRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetKeyspaceDurabilityPolicyResponse) CloneVT() *SetKeyspaceDurabilityPolicyResponse { + if m == nil { + return (*SetKeyspaceDurabilityPolicyResponse)(nil) + } + r := &SetKeyspaceDurabilityPolicyResponse{ + Keyspace: m.Keyspace.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetKeyspaceDurabilityPolicyResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetKeyspaceServedFromRequest) CloneVT() *SetKeyspaceServedFromRequest { + if m == nil { + return (*SetKeyspaceServedFromRequest)(nil) + } + r := &SetKeyspaceServedFromRequest{ + Keyspace: m.Keyspace, + TabletType: m.TabletType, + Remove: m.Remove, + SourceKeyspace: m.SourceKeyspace, + } + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetKeyspaceServedFromRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetKeyspaceServedFromResponse) CloneVT() *SetKeyspaceServedFromResponse { + if m == nil { + return (*SetKeyspaceServedFromResponse)(nil) + } + r := &SetKeyspaceServedFromResponse{ + Keyspace: m.Keyspace.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetKeyspaceServedFromResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetKeyspaceShardingInfoRequest) CloneVT() *SetKeyspaceShardingInfoRequest { + if m == nil { + return (*SetKeyspaceShardingInfoRequest)(nil) + } + r := &SetKeyspaceShardingInfoRequest{ + Keyspace: m.Keyspace, + Force: m.Force, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetKeyspaceShardingInfoRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetKeyspaceShardingInfoResponse) CloneVT() *SetKeyspaceShardingInfoResponse { + if m == nil { + return (*SetKeyspaceShardingInfoResponse)(nil) + } + r := &SetKeyspaceShardingInfoResponse{ + Keyspace: m.Keyspace.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetKeyspaceShardingInfoResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetShardIsPrimaryServingRequest) CloneVT() *SetShardIsPrimaryServingRequest { + if m == nil { + return (*SetShardIsPrimaryServingRequest)(nil) + } + r := &SetShardIsPrimaryServingRequest{ + Keyspace: m.Keyspace, + Shard: m.Shard, + IsServing: m.IsServing, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetShardIsPrimaryServingRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetShardIsPrimaryServingResponse) CloneVT() *SetShardIsPrimaryServingResponse { + if m == nil { + return (*SetShardIsPrimaryServingResponse)(nil) + } + r := &SetShardIsPrimaryServingResponse{ + Shard: m.Shard.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetShardIsPrimaryServingResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetShardTabletControlRequest) CloneVT() *SetShardTabletControlRequest { + if m == nil { + return (*SetShardTabletControlRequest)(nil) + } + r := &SetShardTabletControlRequest{ + Keyspace: m.Keyspace, + Shard: m.Shard, + TabletType: m.TabletType, + DisableQueryService: m.DisableQueryService, + Remove: m.Remove, + } + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if rhs := m.DeniedTables; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.DeniedTables = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetShardTabletControlRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetShardTabletControlResponse) CloneVT() *SetShardTabletControlResponse { + if m == nil { + return (*SetShardTabletControlResponse)(nil) + } + r := &SetShardTabletControlResponse{ + Shard: m.Shard.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetShardTabletControlResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetWritableRequest) CloneVT() *SetWritableRequest { + if m == nil { + return (*SetWritableRequest)(nil) + } + r := &SetWritableRequest{ + TabletAlias: m.TabletAlias.CloneVT(), + Writable: m.Writable, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetWritableRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SetWritableResponse) CloneVT() *SetWritableResponse { + if m == nil { + return (*SetWritableResponse)(nil) + } + r := &SetWritableResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SetWritableResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ShardReplicationAddRequest) CloneVT() *ShardReplicationAddRequest { + if m == nil { + return (*ShardReplicationAddRequest)(nil) + } + r := &ShardReplicationAddRequest{ + Keyspace: m.Keyspace, + Shard: m.Shard, + TabletAlias: m.TabletAlias.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ShardReplicationAddRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ShardReplicationAddResponse) CloneVT() *ShardReplicationAddResponse { + if m == nil { + return (*ShardReplicationAddResponse)(nil) + } + r := &ShardReplicationAddResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ShardReplicationAddResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ShardReplicationFixRequest) CloneVT() *ShardReplicationFixRequest { + if m == nil { + return (*ShardReplicationFixRequest)(nil) + } + r := &ShardReplicationFixRequest{ + Keyspace: m.Keyspace, + Shard: m.Shard, + Cell: m.Cell, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ShardReplicationFixRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ShardReplicationFixResponse) CloneVT() *ShardReplicationFixResponse { + if m == nil { + return (*ShardReplicationFixResponse)(nil) + } + r := &ShardReplicationFixResponse{ + Error: m.Error.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ShardReplicationFixResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ShardReplicationPositionsRequest) CloneVT() *ShardReplicationPositionsRequest { + if m == nil { + return (*ShardReplicationPositionsRequest)(nil) + } + r := &ShardReplicationPositionsRequest{ + Keyspace: m.Keyspace, + Shard: m.Shard, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ShardReplicationPositionsRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ShardReplicationPositionsResponse) CloneVT() *ShardReplicationPositionsResponse { + if m == nil { + return (*ShardReplicationPositionsResponse)(nil) + } + r := &ShardReplicationPositionsResponse{} + if rhs := m.ReplicationStatuses; rhs != nil { + tmpContainer := make(map[string]*replicationdata.Status, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ReplicationStatuses = tmpContainer + } + if rhs := m.TabletMap; rhs != nil { + tmpContainer := make(map[string]*topodata.Tablet, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.TabletMap = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ShardReplicationPositionsResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ShardReplicationRemoveRequest) CloneVT() *ShardReplicationRemoveRequest { + if m == nil { + return (*ShardReplicationRemoveRequest)(nil) + } + r := &ShardReplicationRemoveRequest{ + Keyspace: m.Keyspace, + Shard: m.Shard, + TabletAlias: m.TabletAlias.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ShardReplicationRemoveRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ShardReplicationRemoveResponse) CloneVT() *ShardReplicationRemoveResponse { + if m == nil { + return (*ShardReplicationRemoveResponse)(nil) + } + r := &ShardReplicationRemoveResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ShardReplicationRemoveResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SleepTabletRequest) CloneVT() *SleepTabletRequest { + if m == nil { + return (*SleepTabletRequest)(nil) + } + r := &SleepTabletRequest{ + TabletAlias: m.TabletAlias.CloneVT(), + Duration: m.Duration.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SleepTabletRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SleepTabletResponse) CloneVT() *SleepTabletResponse { + if m == nil { + return (*SleepTabletResponse)(nil) + } + r := &SleepTabletResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SleepTabletResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SourceShardAddRequest) CloneVT() *SourceShardAddRequest { + if m == nil { + return (*SourceShardAddRequest)(nil) + } + r := &SourceShardAddRequest{ + Keyspace: m.Keyspace, + Shard: m.Shard, + Uid: m.Uid, + SourceKeyspace: m.SourceKeyspace, + SourceShard: m.SourceShard, + KeyRange: m.KeyRange.CloneVT(), + } + if rhs := m.Tables; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Tables = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SourceShardAddRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SourceShardAddResponse) CloneVT() *SourceShardAddResponse { + if m == nil { + return (*SourceShardAddResponse)(nil) + } + r := &SourceShardAddResponse{ + Shard: m.Shard.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SourceShardAddResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SourceShardDeleteRequest) CloneVT() *SourceShardDeleteRequest { + if m == nil { + return (*SourceShardDeleteRequest)(nil) + } + r := &SourceShardDeleteRequest{ + Keyspace: m.Keyspace, + Shard: m.Shard, + Uid: m.Uid, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SourceShardDeleteRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *SourceShardDeleteResponse) CloneVT() *SourceShardDeleteResponse { + if m == nil { + return (*SourceShardDeleteResponse)(nil) + } + r := &SourceShardDeleteResponse{ + Shard: m.Shard.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *SourceShardDeleteResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StartReplicationRequest) CloneVT() *StartReplicationRequest { + if m == nil { + return (*StartReplicationRequest)(nil) + } + r := &StartReplicationRequest{ + TabletAlias: m.TabletAlias.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StartReplicationRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StartReplicationResponse) CloneVT() *StartReplicationResponse { + if m == nil { + return (*StartReplicationResponse)(nil) + } + r := &StartReplicationResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StartReplicationResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StopReplicationRequest) CloneVT() *StopReplicationRequest { + if m == nil { + return (*StopReplicationRequest)(nil) + } + r := &StopReplicationRequest{ + TabletAlias: m.TabletAlias.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StopReplicationRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StopReplicationResponse) CloneVT() *StopReplicationResponse { + if m == nil { + return (*StopReplicationResponse)(nil) + } + r := &StopReplicationResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StopReplicationResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *TabletExternallyReparentedRequest) CloneVT() *TabletExternallyReparentedRequest { + if m == nil { + return (*TabletExternallyReparentedRequest)(nil) + } + r := &TabletExternallyReparentedRequest{ + Tablet: m.Tablet.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *TabletExternallyReparentedRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *TabletExternallyReparentedResponse) CloneVT() *TabletExternallyReparentedResponse { + if m == nil { + return (*TabletExternallyReparentedResponse)(nil) + } + r := &TabletExternallyReparentedResponse{ + Keyspace: m.Keyspace, + Shard: m.Shard, + NewPrimary: m.NewPrimary.CloneVT(), + OldPrimary: m.OldPrimary.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *TabletExternallyReparentedResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UpdateCellInfoRequest) CloneVT() *UpdateCellInfoRequest { + if m == nil { + return (*UpdateCellInfoRequest)(nil) + } + r := &UpdateCellInfoRequest{ + Name: m.Name, + CellInfo: m.CellInfo.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UpdateCellInfoRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UpdateCellInfoResponse) CloneVT() *UpdateCellInfoResponse { + if m == nil { + return (*UpdateCellInfoResponse)(nil) + } + r := &UpdateCellInfoResponse{ + Name: m.Name, + CellInfo: m.CellInfo.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UpdateCellInfoResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UpdateCellsAliasRequest) CloneVT() *UpdateCellsAliasRequest { + if m == nil { + return (*UpdateCellsAliasRequest)(nil) + } + r := &UpdateCellsAliasRequest{ + Name: m.Name, + CellsAlias: m.CellsAlias.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UpdateCellsAliasRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *UpdateCellsAliasResponse) CloneVT() *UpdateCellsAliasResponse { + if m == nil { + return (*UpdateCellsAliasResponse)(nil) + } + r := &UpdateCellsAliasResponse{ + Name: m.Name, + CellsAlias: m.CellsAlias.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *UpdateCellsAliasResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ValidateRequest) CloneVT() *ValidateRequest { + if m == nil { + return (*ValidateRequest)(nil) + } + r := &ValidateRequest{ + PingTablets: m.PingTablets, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ValidateRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ValidateResponse) CloneVT() *ValidateResponse { + if m == nil { + return (*ValidateResponse)(nil) + } + r := &ValidateResponse{} + if rhs := m.Results; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Results = tmpContainer + } + if rhs := m.ResultsByKeyspace; rhs != nil { + tmpContainer := make(map[string]*ValidateKeyspaceResponse, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ResultsByKeyspace = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ValidateResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ValidateKeyspaceRequest) CloneVT() *ValidateKeyspaceRequest { + if m == nil { + return (*ValidateKeyspaceRequest)(nil) + } + r := &ValidateKeyspaceRequest{ + Keyspace: m.Keyspace, + PingTablets: m.PingTablets, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ValidateKeyspaceRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ValidateKeyspaceResponse) CloneVT() *ValidateKeyspaceResponse { + if m == nil { + return (*ValidateKeyspaceResponse)(nil) + } + r := &ValidateKeyspaceResponse{} + if rhs := m.Results; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Results = tmpContainer + } + if rhs := m.ResultsByShard; rhs != nil { + tmpContainer := make(map[string]*ValidateShardResponse, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ResultsByShard = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ValidateKeyspaceResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ValidateSchemaKeyspaceRequest) CloneVT() *ValidateSchemaKeyspaceRequest { + if m == nil { + return (*ValidateSchemaKeyspaceRequest)(nil) + } + r := &ValidateSchemaKeyspaceRequest{ + Keyspace: m.Keyspace, + IncludeViews: m.IncludeViews, + SkipNoPrimary: m.SkipNoPrimary, + IncludeVschema: m.IncludeVschema, + } + if rhs := m.ExcludeTables; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ExcludeTables = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ValidateSchemaKeyspaceRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ValidateSchemaKeyspaceResponse) CloneVT() *ValidateSchemaKeyspaceResponse { + if m == nil { + return (*ValidateSchemaKeyspaceResponse)(nil) + } + r := &ValidateSchemaKeyspaceResponse{} + if rhs := m.Results; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Results = tmpContainer + } + if rhs := m.ResultsByShard; rhs != nil { + tmpContainer := make(map[string]*ValidateShardResponse, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ResultsByShard = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ValidateSchemaKeyspaceResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ValidateShardRequest) CloneVT() *ValidateShardRequest { + if m == nil { + return (*ValidateShardRequest)(nil) + } + r := &ValidateShardRequest{ + Keyspace: m.Keyspace, + Shard: m.Shard, + PingTablets: m.PingTablets, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ValidateShardRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ValidateShardResponse) CloneVT() *ValidateShardResponse { + if m == nil { + return (*ValidateShardResponse)(nil) + } + r := &ValidateShardResponse{} + if rhs := m.Results; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Results = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ValidateShardResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ValidateVersionKeyspaceRequest) CloneVT() *ValidateVersionKeyspaceRequest { + if m == nil { + return (*ValidateVersionKeyspaceRequest)(nil) + } + r := &ValidateVersionKeyspaceRequest{ + Keyspace: m.Keyspace, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ValidateVersionKeyspaceRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ValidateVersionKeyspaceResponse) CloneVT() *ValidateVersionKeyspaceResponse { + if m == nil { + return (*ValidateVersionKeyspaceResponse)(nil) + } + r := &ValidateVersionKeyspaceResponse{} + if rhs := m.Results; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Results = tmpContainer + } + if rhs := m.ResultsByShard; rhs != nil { + tmpContainer := make(map[string]*ValidateShardResponse, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ResultsByShard = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ValidateVersionKeyspaceResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ValidateVersionShardRequest) CloneVT() *ValidateVersionShardRequest { + if m == nil { + return (*ValidateVersionShardRequest)(nil) + } + r := &ValidateVersionShardRequest{ + Keyspace: m.Keyspace, + Shard: m.Shard, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ValidateVersionShardRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ValidateVersionShardResponse) CloneVT() *ValidateVersionShardResponse { + if m == nil { + return (*ValidateVersionShardResponse)(nil) + } + r := &ValidateVersionShardResponse{} + if rhs := m.Results; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Results = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ValidateVersionShardResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ValidateVSchemaRequest) CloneVT() *ValidateVSchemaRequest { + if m == nil { + return (*ValidateVSchemaRequest)(nil) + } + r := &ValidateVSchemaRequest{ + Keyspace: m.Keyspace, + IncludeViews: m.IncludeViews, + } + if rhs := m.Shards; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Shards = tmpContainer + } + if rhs := m.ExcludeTables; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.ExcludeTables = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ValidateVSchemaRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ValidateVSchemaResponse) CloneVT() *ValidateVSchemaResponse { + if m == nil { + return (*ValidateVSchemaResponse)(nil) + } + r := &ValidateVSchemaResponse{} + if rhs := m.Results; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Results = tmpContainer + } + if rhs := m.ResultsByShard; rhs != nil { + tmpContainer := make(map[string]*ValidateShardResponse, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ResultsByShard = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ValidateVSchemaResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *WorkflowDeleteRequest) CloneVT() *WorkflowDeleteRequest { + if m == nil { + return (*WorkflowDeleteRequest)(nil) + } + r := &WorkflowDeleteRequest{ + Keyspace: m.Keyspace, + Workflow: m.Workflow, + KeepData: m.KeepData, + KeepRoutingRules: m.KeepRoutingRules, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *WorkflowDeleteRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *WorkflowDeleteResponse_TabletInfo) CloneVT() *WorkflowDeleteResponse_TabletInfo { + if m == nil { + return (*WorkflowDeleteResponse_TabletInfo)(nil) + } + r := &WorkflowDeleteResponse_TabletInfo{ + Tablet: m.Tablet.CloneVT(), + Deleted: m.Deleted, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *WorkflowDeleteResponse_TabletInfo) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *WorkflowDeleteResponse) CloneVT() *WorkflowDeleteResponse { + if m == nil { + return (*WorkflowDeleteResponse)(nil) + } + r := &WorkflowDeleteResponse{ + Summary: m.Summary, + } + if rhs := m.Details; rhs != nil { + tmpContainer := make([]*WorkflowDeleteResponse_TabletInfo, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Details = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *WorkflowDeleteResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *WorkflowStatusRequest) CloneVT() *WorkflowStatusRequest { + if m == nil { + return (*WorkflowStatusRequest)(nil) + } + r := &WorkflowStatusRequest{ + Keyspace: m.Keyspace, + Workflow: m.Workflow, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *WorkflowStatusRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *WorkflowStatusResponse_TableCopyState) CloneVT() *WorkflowStatusResponse_TableCopyState { + if m == nil { + return (*WorkflowStatusResponse_TableCopyState)(nil) + } + r := &WorkflowStatusResponse_TableCopyState{ + RowsCopied: m.RowsCopied, + RowsTotal: m.RowsTotal, + RowsPercentage: m.RowsPercentage, + BytesCopied: m.BytesCopied, + BytesTotal: m.BytesTotal, + BytesPercentage: m.BytesPercentage, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *WorkflowStatusResponse_TableCopyState) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *WorkflowStatusResponse_ShardStreamState) CloneVT() *WorkflowStatusResponse_ShardStreamState { + if m == nil { + return (*WorkflowStatusResponse_ShardStreamState)(nil) + } + r := &WorkflowStatusResponse_ShardStreamState{ + Id: m.Id, + Tablet: m.Tablet.CloneVT(), + SourceShard: m.SourceShard, + Position: m.Position, + Status: m.Status, + Info: m.Info, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *WorkflowStatusResponse_ShardStreamState) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *WorkflowStatusResponse_ShardStreams) CloneVT() *WorkflowStatusResponse_ShardStreams { + if m == nil { + return (*WorkflowStatusResponse_ShardStreams)(nil) + } + r := &WorkflowStatusResponse_ShardStreams{} + if rhs := m.Streams; rhs != nil { + tmpContainer := make([]*WorkflowStatusResponse_ShardStreamState, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Streams = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *WorkflowStatusResponse_ShardStreams) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *WorkflowStatusResponse) CloneVT() *WorkflowStatusResponse { + if m == nil { + return (*WorkflowStatusResponse)(nil) + } + r := &WorkflowStatusResponse{} + if rhs := m.TableCopyState; rhs != nil { + tmpContainer := make(map[string]*WorkflowStatusResponse_TableCopyState, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.TableCopyState = tmpContainer + } + if rhs := m.ShardStreams; rhs != nil { + tmpContainer := make(map[string]*WorkflowStatusResponse_ShardStreams, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ShardStreams = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *WorkflowStatusResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *WorkflowSwitchTrafficRequest) CloneVT() *WorkflowSwitchTrafficRequest { + if m == nil { + return (*WorkflowSwitchTrafficRequest)(nil) + } + r := &WorkflowSwitchTrafficRequest{ + Keyspace: m.Keyspace, + Workflow: m.Workflow, + MaxReplicationLagAllowed: m.MaxReplicationLagAllowed.CloneVT(), + EnableReverseReplication: m.EnableReverseReplication, + Direction: m.Direction, + Timeout: m.Timeout.CloneVT(), + DryRun: m.DryRun, + InitializeTargetSequences: m.InitializeTargetSequences, + } + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if rhs := m.TabletTypes; rhs != nil { + tmpContainer := make([]topodata.TabletType, len(rhs)) + copy(tmpContainer, rhs) + r.TabletTypes = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *WorkflowSwitchTrafficRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *WorkflowSwitchTrafficResponse) CloneVT() *WorkflowSwitchTrafficResponse { + if m == nil { + return (*WorkflowSwitchTrafficResponse)(nil) + } + r := &WorkflowSwitchTrafficResponse{ + Summary: m.Summary, + StartState: m.StartState, + CurrentState: m.CurrentState, + } + if rhs := m.DryRunResults; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.DryRunResults = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *WorkflowSwitchTrafficResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *WorkflowUpdateRequest) CloneVT() *WorkflowUpdateRequest { + if m == nil { + return (*WorkflowUpdateRequest)(nil) + } + r := &WorkflowUpdateRequest{ + Keyspace: m.Keyspace, + TabletRequest: m.TabletRequest.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *WorkflowUpdateRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *WorkflowUpdateResponse_TabletInfo) CloneVT() *WorkflowUpdateResponse_TabletInfo { + if m == nil { + return (*WorkflowUpdateResponse_TabletInfo)(nil) + } + r := &WorkflowUpdateResponse_TabletInfo{ + Tablet: m.Tablet.CloneVT(), + Changed: m.Changed, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *WorkflowUpdateResponse_TabletInfo) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *WorkflowUpdateResponse) CloneVT() *WorkflowUpdateResponse { + if m == nil { + return (*WorkflowUpdateResponse)(nil) + } + r := &WorkflowUpdateResponse{ + Summary: m.Summary, + } + if rhs := m.Details; rhs != nil { + tmpContainer := make([]*WorkflowUpdateResponse_TabletInfo, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Details = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *WorkflowUpdateResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + func (m *ExecuteVtctlCommandRequest) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil diff --git a/go/vt/proto/vtgate/vtgate_vtproto.pb.go b/go/vt/proto/vtgate/vtgate_vtproto.pb.go index b3073965c9a..bec24472760 100644 --- a/go/vt/proto/vtgate/vtgate_vtproto.pb.go +++ b/go/vt/proto/vtgate/vtgate_vtproto.pb.go @@ -1,5 +1,5 @@ // Code generated by protoc-gen-go-vtproto. DO NOT EDIT. -// protoc-gen-go-vtproto version: v0.4.0 +// protoc-gen-go-vtproto version: v0.5.0 // source: vtgate.proto package vtgate @@ -7,6 +7,7 @@ package vtgate import ( binary "encoding/binary" fmt "fmt" + proto "google.golang.org/protobuf/proto" protoimpl "google.golang.org/protobuf/runtime/protoimpl" io "io" math "math" @@ -24,6 +25,479 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +func (m *Session_ShardSession) CloneVT() *Session_ShardSession { + if m == nil { + return (*Session_ShardSession)(nil) + } + r := &Session_ShardSession{ + Target: m.Target.CloneVT(), + TransactionId: m.TransactionId, + TabletAlias: m.TabletAlias.CloneVT(), + ReservedId: m.ReservedId, + VindexOnly: m.VindexOnly, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Session_ShardSession) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Session) CloneVT() *Session { + if m == nil { + return (*Session)(nil) + } + r := &Session{ + InTransaction: m.InTransaction, + Autocommit: m.Autocommit, + TargetString: m.TargetString, + Options: m.Options.CloneVT(), + TransactionMode: m.TransactionMode, + LastInsertId: m.LastInsertId, + FoundRows: m.FoundRows, + RowCount: m.RowCount, + InReservedConn: m.InReservedConn, + LockSession: m.LockSession.CloneVT(), + LastLockHeartbeat: m.LastLockHeartbeat, + ReadAfterWrite: m.ReadAfterWrite.CloneVT(), + DDLStrategy: m.DDLStrategy, + SessionUUID: m.SessionUUID, + EnableSystemSettings: m.EnableSystemSettings, + QueryTimeout: m.QueryTimeout, + MigrationContext: m.MigrationContext, + } + if rhs := m.ShardSessions; rhs != nil { + tmpContainer := make([]*Session_ShardSession, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.ShardSessions = tmpContainer + } + if rhs := m.Warnings; rhs != nil { + tmpContainer := make([]*query.QueryWarning, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Warnings = tmpContainer + } + if rhs := m.PreSessions; rhs != nil { + tmpContainer := make([]*Session_ShardSession, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.PreSessions = tmpContainer + } + if rhs := m.PostSessions; rhs != nil { + tmpContainer := make([]*Session_ShardSession, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.PostSessions = tmpContainer + } + if rhs := m.UserDefinedVariables; rhs != nil { + tmpContainer := make(map[string]*query.BindVariable, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.UserDefinedVariables = tmpContainer + } + if rhs := m.SystemVariables; rhs != nil { + tmpContainer := make(map[string]string, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.SystemVariables = tmpContainer + } + if rhs := m.Savepoints; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Savepoints = tmpContainer + } + if rhs := m.AdvisoryLock; rhs != nil { + tmpContainer := make(map[string]int64, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v + } + r.AdvisoryLock = tmpContainer + } + if rhs := m.PrepareStatement; rhs != nil { + tmpContainer := make(map[string]*PrepareData, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.PrepareStatement = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Session) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PrepareData) CloneVT() *PrepareData { + if m == nil { + return (*PrepareData)(nil) + } + r := &PrepareData{ + PrepareStatement: m.PrepareStatement, + ParamsCount: m.ParamsCount, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PrepareData) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ReadAfterWrite) CloneVT() *ReadAfterWrite { + if m == nil { + return (*ReadAfterWrite)(nil) + } + r := &ReadAfterWrite{ + ReadAfterWriteGtid: m.ReadAfterWriteGtid, + ReadAfterWriteTimeout: m.ReadAfterWriteTimeout, + SessionTrackGtids: m.SessionTrackGtids, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ReadAfterWrite) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteRequest) CloneVT() *ExecuteRequest { + if m == nil { + return (*ExecuteRequest)(nil) + } + r := &ExecuteRequest{ + CallerId: m.CallerId.CloneVT(), + Session: m.Session.CloneVT(), + Query: m.Query.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteResponse) CloneVT() *ExecuteResponse { + if m == nil { + return (*ExecuteResponse)(nil) + } + r := &ExecuteResponse{ + Error: m.Error.CloneVT(), + Session: m.Session.CloneVT(), + Result: m.Result.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteBatchRequest) CloneVT() *ExecuteBatchRequest { + if m == nil { + return (*ExecuteBatchRequest)(nil) + } + r := &ExecuteBatchRequest{ + CallerId: m.CallerId.CloneVT(), + Session: m.Session.CloneVT(), + } + if rhs := m.Queries; rhs != nil { + tmpContainer := make([]*query.BoundQuery, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Queries = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteBatchRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ExecuteBatchResponse) CloneVT() *ExecuteBatchResponse { + if m == nil { + return (*ExecuteBatchResponse)(nil) + } + r := &ExecuteBatchResponse{ + Error: m.Error.CloneVT(), + Session: m.Session.CloneVT(), + } + if rhs := m.Results; rhs != nil { + tmpContainer := make([]*query.ResultWithError, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Results = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ExecuteBatchResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StreamExecuteRequest) CloneVT() *StreamExecuteRequest { + if m == nil { + return (*StreamExecuteRequest)(nil) + } + r := &StreamExecuteRequest{ + CallerId: m.CallerId.CloneVT(), + Query: m.Query.CloneVT(), + Session: m.Session.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StreamExecuteRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *StreamExecuteResponse) CloneVT() *StreamExecuteResponse { + if m == nil { + return (*StreamExecuteResponse)(nil) + } + r := &StreamExecuteResponse{ + Result: m.Result.CloneVT(), + Session: m.Session.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *StreamExecuteResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ResolveTransactionRequest) CloneVT() *ResolveTransactionRequest { + if m == nil { + return (*ResolveTransactionRequest)(nil) + } + r := &ResolveTransactionRequest{ + CallerId: m.CallerId.CloneVT(), + Dtid: m.Dtid, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ResolveTransactionRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ResolveTransactionResponse) CloneVT() *ResolveTransactionResponse { + if m == nil { + return (*ResolveTransactionResponse)(nil) + } + r := &ResolveTransactionResponse{} + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ResolveTransactionResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VStreamFlags) CloneVT() *VStreamFlags { + if m == nil { + return (*VStreamFlags)(nil) + } + r := &VStreamFlags{ + MinimizeSkew: m.MinimizeSkew, + HeartbeatInterval: m.HeartbeatInterval, + StopOnReshard: m.StopOnReshard, + Cells: m.Cells, + CellPreference: m.CellPreference, + TabletOrder: m.TabletOrder, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VStreamFlags) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VStreamRequest) CloneVT() *VStreamRequest { + if m == nil { + return (*VStreamRequest)(nil) + } + r := &VStreamRequest{ + CallerId: m.CallerId.CloneVT(), + TabletType: m.TabletType, + Vgtid: m.Vgtid.CloneVT(), + Filter: m.Filter.CloneVT(), + Flags: m.Flags.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VStreamRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VStreamResponse) CloneVT() *VStreamResponse { + if m == nil { + return (*VStreamResponse)(nil) + } + r := &VStreamResponse{} + if rhs := m.Events; rhs != nil { + tmpContainer := make([]*binlogdata.VEvent, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Events = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VStreamResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PrepareRequest) CloneVT() *PrepareRequest { + if m == nil { + return (*PrepareRequest)(nil) + } + r := &PrepareRequest{ + CallerId: m.CallerId.CloneVT(), + Session: m.Session.CloneVT(), + Query: m.Query.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PrepareRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *PrepareResponse) CloneVT() *PrepareResponse { + if m == nil { + return (*PrepareResponse)(nil) + } + r := &PrepareResponse{ + Error: m.Error.CloneVT(), + Session: m.Session.CloneVT(), + } + if rhs := m.Fields; rhs != nil { + tmpContainer := make([]*query.Field, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Fields = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *PrepareResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CloseSessionRequest) CloneVT() *CloseSessionRequest { + if m == nil { + return (*CloseSessionRequest)(nil) + } + r := &CloseSessionRequest{ + CallerId: m.CallerId.CloneVT(), + Session: m.Session.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CloseSessionRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *CloseSessionResponse) CloneVT() *CloseSessionResponse { + if m == nil { + return (*CloseSessionResponse)(nil) + } + r := &CloseSessionResponse{ + Error: m.Error.CloneVT(), + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CloseSessionResponse) CloneMessageVT() proto.Message { + return m.CloneVT() +} + func (m *Session_ShardSession) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil diff --git a/go/vt/proto/vtrpc/vtrpc_vtproto.pb.go b/go/vt/proto/vtrpc/vtrpc_vtproto.pb.go index 008fe7aa100..36fb8ba8627 100644 --- a/go/vt/proto/vtrpc/vtrpc_vtproto.pb.go +++ b/go/vt/proto/vtrpc/vtrpc_vtproto.pb.go @@ -1,11 +1,12 @@ // Code generated by protoc-gen-go-vtproto. DO NOT EDIT. -// protoc-gen-go-vtproto version: v0.4.0 +// protoc-gen-go-vtproto version: v0.5.0 // source: vtrpc.proto package vtrpc import ( fmt "fmt" + proto "google.golang.org/protobuf/proto" protoimpl "google.golang.org/protobuf/runtime/protoimpl" io "io" bits "math/bits" @@ -18,6 +19,50 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +func (m *CallerID) CloneVT() *CallerID { + if m == nil { + return (*CallerID)(nil) + } + r := &CallerID{ + Principal: m.Principal, + Component: m.Component, + Subcomponent: m.Subcomponent, + } + if rhs := m.Groups; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Groups = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *CallerID) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *RPCError) CloneVT() *RPCError { + if m == nil { + return (*RPCError)(nil) + } + r := &RPCError{ + Message: m.Message, + Code: m.Code, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *RPCError) CloneMessageVT() proto.Message { + return m.CloneVT() +} + func (m *CallerID) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil diff --git a/go/vt/proto/vttest/vttest_vtproto.pb.go b/go/vt/proto/vttest/vttest_vtproto.pb.go index a7474446a26..f1dee298011 100644 --- a/go/vt/proto/vttest/vttest_vtproto.pb.go +++ b/go/vt/proto/vttest/vttest_vtproto.pb.go @@ -1,11 +1,12 @@ // Code generated by protoc-gen-go-vtproto. DO NOT EDIT. -// protoc-gen-go-vtproto version: v0.4.0 +// protoc-gen-go-vtproto version: v0.5.0 // source: vttest.proto package vttest import ( fmt "fmt" + proto "google.golang.org/protobuf/proto" protoimpl "google.golang.org/protobuf/runtime/protoimpl" io "io" bits "math/bits" @@ -19,6 +20,83 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +func (m *Shard) CloneVT() *Shard { + if m == nil { + return (*Shard)(nil) + } + r := &Shard{ + Name: m.Name, + DbNameOverride: m.DbNameOverride, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Shard) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Keyspace) CloneVT() *Keyspace { + if m == nil { + return (*Keyspace)(nil) + } + r := &Keyspace{ + Name: m.Name, + ServedFrom: m.ServedFrom, + ReplicaCount: m.ReplicaCount, + RdonlyCount: m.RdonlyCount, + } + if rhs := m.Shards; rhs != nil { + tmpContainer := make([]*Shard, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Shards = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Keyspace) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *VTTestTopology) CloneVT() *VTTestTopology { + if m == nil { + return (*VTTestTopology)(nil) + } + r := &VTTestTopology{ + RoutingRules: m.RoutingRules.CloneVT(), + } + if rhs := m.Keyspaces; rhs != nil { + tmpContainer := make([]*Keyspace, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Keyspaces = tmpContainer + } + if rhs := m.Cells; rhs != nil { + tmpContainer := make([]string, len(rhs)) + copy(tmpContainer, rhs) + r.Cells = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *VTTestTopology) CloneMessageVT() proto.Message { + return m.CloneVT() +} + func (m *Shard) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil diff --git a/go/vt/proto/vttime/vttime_vtproto.pb.go b/go/vt/proto/vttime/vttime_vtproto.pb.go index d1e1ce8a4cc..aa53a902df5 100644 --- a/go/vt/proto/vttime/vttime_vtproto.pb.go +++ b/go/vt/proto/vttime/vttime_vtproto.pb.go @@ -1,11 +1,12 @@ // Code generated by protoc-gen-go-vtproto. DO NOT EDIT. -// protoc-gen-go-vtproto version: v0.4.0 +// protoc-gen-go-vtproto version: v0.5.0 // source: vttime.proto package vttime import ( fmt "fmt" + proto "google.golang.org/protobuf/proto" protoimpl "google.golang.org/protobuf/runtime/protoimpl" io "io" bits "math/bits" @@ -18,6 +19,44 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +func (m *Time) CloneVT() *Time { + if m == nil { + return (*Time)(nil) + } + r := &Time{ + Seconds: m.Seconds, + Nanoseconds: m.Nanoseconds, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Time) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *Duration) CloneVT() *Duration { + if m == nil { + return (*Duration)(nil) + } + r := &Duration{ + Seconds: m.Seconds, + Nanos: m.Nanos, + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *Duration) CloneMessageVT() proto.Message { + return m.CloneVT() +} + func (m *Time) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil From 3021c79ecf34c2c9c2a0b3be6c534b0ab4a75aff Mon Sep 17 00:00:00 2001 From: Vicent Marti Date: Tue, 5 Sep 2023 10:51:03 +0200 Subject: [PATCH 4/5] proto: use CloneVT instead of reflection Signed-off-by: Vicent Marti --- go/cmd/vtcombo/main.go | 8 +++----- go/sqltypes/result.go | 2 +- go/vt/discovery/fake_healthcheck.go | 6 +++--- go/vt/discovery/topology_watcher_test.go | 9 ++++----- go/vt/mysqlctl/tmutils/schema.go | 2 +- go/vt/tableacl/tableacl.go | 8 +++----- go/vt/throttler/manager_test.go | 4 +--- go/vt/throttler/max_replication_lag_module.go | 4 ++-- .../max_replication_lag_module_config.go | 6 +----- go/vt/topo/helpers/copy.go | 2 +- go/vt/topo/shard.go | 4 +--- go/vt/topo/tablet.go | 9 +++------ go/vt/vtadmin/api_test.go | 11 ++++------- go/vt/vtadmin/cluster/cluster.go | 5 +---- go/vt/vtadmin/cluster/cluster_test.go | 5 +---- .../internal/caches/schemacache/cache.go | 5 +---- go/vt/vtctl/grpcvtctldserver/server.go | 17 ++++++----------- go/vt/vtctl/grpcvtctldserver/server_test.go | 5 ++--- .../testutil/proto_compare.go | 14 ++++---------- go/vt/vtctl/grpcvtctldserver/testutil/util.go | 6 ++---- .../reparentutil/emergency_reparenter.go | 5 +---- .../vtctl/reparentutil/planned_reparenter.go | 17 ++++++----------- go/vt/vtctl/workflow/server.go | 4 +--- go/vt/vtctl/workflow/vreplication_stream.go | 4 +--- go/vt/vtgate/engine/aggregations.go | 6 +----- go/vt/vtgate/executor_test.go | 4 ++-- go/vt/vtgate/safe_session.go | 2 +- go/vt/vtgate/vschema_manager.go | 7 ++----- go/vt/vtgate/vstream_manager.go | 13 +++++-------- go/vt/vtgate/vstream_manager_test.go | 2 +- go/vt/vttablet/endtoend/framework/client.go | 4 +--- go/vt/vttablet/onlineddl/executor.go | 10 +++------- .../fakes/stream_health_query_service.go | 12 +++++------- go/vt/vttablet/tabletmanager/tm_state.go | 7 +++---- .../tabletmanager/vdiff/table_differ.go | 17 +++++++---------- .../tabletmanager/vreplication/engine.go | 4 +--- .../vreplication/replicator_plan.go | 11 ++++------- .../tabletmanager/vreplication/vcopier.go | 6 ++---- .../vttablet/tabletserver/health_streamer.go | 19 +++++++------------ go/vt/vttablet/tabletserver/query_executor.go | 4 +--- .../tabletserver/repltracker/writer.go | 4 +--- go/vt/vttablet/tabletserver/state_manager.go | 5 ++--- .../tabletserver/state_manager_test.go | 3 +-- go/vt/vttablet/tabletserver/tabletserver.go | 6 ++---- .../tabletserver/txthrottler/tx_throttler.go | 6 +----- .../tabletserver/vstreamer/vstreamer.go | 6 ++---- go/vt/vttablet/tabletservermock/controller.go | 7 ++----- go/vt/wrangler/materializer.go | 2 +- go/vt/wrangler/tablet.go | 4 +--- go/vt/wrangler/traffic_switcher_env_test.go | 6 ++---- 50 files changed, 115 insertions(+), 224 deletions(-) diff --git a/go/cmd/vtcombo/main.go b/go/cmd/vtcombo/main.go index 02c8acbab7f..24994f06c6e 100644 --- a/go/cmd/vtcombo/main.go +++ b/go/cmd/vtcombo/main.go @@ -28,12 +28,10 @@ import ( "time" "github.com/spf13/pflag" - "google.golang.org/protobuf/proto" - - "vitess.io/vitess/go/mysql/replication" "vitess.io/vitess/go/acl" "vitess.io/vitess/go/exit" + "vitess.io/vitess/go/mysql/replication" "vitess.io/vitess/go/vt/dbconfigs" "vitess.io/vitess/go/vt/log" "vitess.io/vitess/go/vt/logutil" @@ -165,7 +163,7 @@ func main() { // // We will use this to determine the shard structure when keyspaces // get recreated. - originalTopology := proto.Clone(&tpb).(*vttestpb.VTTestTopology) + originalTopology := (&tpb).CloneVT() // default cell to "test" if unspecified if len(tpb.Cells) == 0 { @@ -240,7 +238,7 @@ func main() { // will end up with the same number of shards. for _, originalKs := range originalTopology.Keyspaces { if originalKs.Name == ks.Name { - ks = proto.Clone(originalKs).(*vttestpb.Keyspace) + ks = originalKs.CloneVT() } } diff --git a/go/sqltypes/result.go b/go/sqltypes/result.go index 80952598ec9..7c04e1d89fa 100644 --- a/go/sqltypes/result.go +++ b/go/sqltypes/result.go @@ -99,7 +99,7 @@ func (result *Result) Copy() *Result { if result.Fields != nil { out.Fields = make([]*querypb.Field, len(result.Fields)) for i, f := range result.Fields { - out.Fields[i] = proto.Clone(f).(*querypb.Field) + out.Fields[i] = f.CloneVT() } } if result.Rows != nil { diff --git a/go/vt/discovery/fake_healthcheck.go b/go/vt/discovery/fake_healthcheck.go index d3e9adfeded..cb959902c19 100644 --- a/go/vt/discovery/fake_healthcheck.go +++ b/go/vt/discovery/fake_healthcheck.go @@ -380,9 +380,9 @@ func (fhc *FakeHealthCheck) BroadcastAll() { func simpleCopy(th *TabletHealth) *TabletHealth { return &TabletHealth{ Conn: th.Conn, - Tablet: proto.Clone(th.Tablet).(*topodatapb.Tablet), - Target: proto.Clone(th.Target).(*querypb.Target), - Stats: proto.Clone(th.Stats).(*querypb.RealtimeStats), + Tablet: th.Tablet.CloneVT(), + Target: th.Target.CloneVT(), + Stats: th.Stats.CloneVT(), LastError: th.LastError, PrimaryTermStartTime: th.PrimaryTermStartTime, Serving: th.Serving, diff --git a/go/vt/discovery/topology_watcher_test.go b/go/vt/discovery/topology_watcher_test.go index f0dfe2da833..3ac567acef8 100644 --- a/go/vt/discovery/topology_watcher_test.go +++ b/go/vt/discovery/topology_watcher_test.go @@ -207,7 +207,7 @@ func checkWatcher(t *testing.T, refreshKnownTablets bool) { // if refreshKnownTablets is disabled, this case is *not* // detected and the tablet remains in the topo using the // old key - origTablet := proto.Clone(tablet).(*topodatapb.Tablet) + origTablet := tablet.CloneVT() origKey := TabletToMapKey(tablet) tablet.PortMap["vt"] = 456 if _, err := ts.UpdateTabletFields(context.Background(), tablet.Alias, func(t *topodatapb.Tablet) error { @@ -246,9 +246,8 @@ func checkWatcher(t *testing.T, refreshKnownTablets bool) { // tablet2 happens to land on the host:port that tablet 1 used to be on. // This can only be tested when we refresh known tablets. if refreshKnownTablets { - origTablet := proto.Clone(tablet).(*topodatapb.Tablet) - origTablet2 := proto.Clone(tablet2).(*topodatapb.Tablet) - + origTablet := tablet.CloneVT() + origTablet2 := tablet2.CloneVT() if _, err := ts.UpdateTabletFields(context.Background(), tablet2.Alias, func(t *topodatapb.Tablet) error { t.Hostname = tablet.Hostname t.PortMap = tablet.PortMap @@ -607,7 +606,7 @@ func TestFilterByKeypsaceSkipsIgnoredTablets(t *testing.T) { allTablets = fhc.GetAllTablets() assert.Len(t, allTablets, 1) origKey := TabletToMapKey(tablet) - tabletWithNewPort := proto.Clone(tablet).(*topodatapb.Tablet) + tabletWithNewPort := tablet.CloneVT() tabletWithNewPort.PortMap["vt"] = 456 keyWithNewPort := TabletToMapKey(tabletWithNewPort) assert.Contains(t, allTablets, origKey) diff --git a/go/vt/mysqlctl/tmutils/schema.go b/go/vt/mysqlctl/tmutils/schema.go index 694b02abf5e..aae529f89b0 100644 --- a/go/vt/mysqlctl/tmutils/schema.go +++ b/go/vt/mysqlctl/tmutils/schema.go @@ -177,7 +177,7 @@ func (f *TableFilter) Includes(tableName string, tableType string) bool { // (tables), no denied tables (excludeTables) and optionally // views (includeViews). func FilterTables(sd *tabletmanagerdatapb.SchemaDefinition, tables, excludeTables []string, includeViews bool) (*tabletmanagerdatapb.SchemaDefinition, error) { - copy := proto.Clone(sd).(*tabletmanagerdatapb.SchemaDefinition) + copy := sd.CloneVT() copy.TableDefinitions = make([]*tabletmanagerdatapb.TableDefinition, 0, len(sd.TableDefinitions)) f, err := NewTableFilter(tables, excludeTables, includeViews) diff --git a/go/vt/tableacl/tableacl.go b/go/vt/tableacl/tableacl.go index 4ee46ae7739..9a6e6eeba4e 100644 --- a/go/vt/tableacl/tableacl.go +++ b/go/vt/tableacl/tableacl.go @@ -26,13 +26,11 @@ import ( "sync" "github.com/tchap/go-patricia/patricia" - "google.golang.org/protobuf/proto" "vitess.io/vitess/go/json2" "vitess.io/vitess/go/vt/log" - "vitess.io/vitess/go/vt/tableacl/acl" - tableaclpb "vitess.io/vitess/go/vt/proto/tableacl" + "vitess.io/vitess/go/vt/tableacl/acl" ) // ACLResult embeds an acl.ACL and also tell which table group it belongs to. @@ -188,7 +186,7 @@ func (tacl *tableACL) Set(config *tableaclpb.Config) error { } tacl.Lock() tacl.entries = entries - tacl.config = proto.Clone(config).(*tableaclpb.Config) + tacl.config = config.CloneVT() callback := tacl.callback tacl.Unlock() if callback != nil { @@ -277,7 +275,7 @@ func GetCurrentConfig() *tableaclpb.Config { func (tacl *tableACL) Config() *tableaclpb.Config { tacl.RLock() defer tacl.RUnlock() - return proto.Clone(tacl.config).(*tableaclpb.Config) + return tacl.config.CloneVT() } // Register registers an AclFactory. diff --git a/go/vt/throttler/manager_test.go b/go/vt/throttler/manager_test.go index 8c0e6ae4563..e6c3359b242 100644 --- a/go/vt/throttler/manager_test.go +++ b/go/vt/throttler/manager_test.go @@ -24,8 +24,6 @@ import ( "testing" "time" - "google.golang.org/protobuf/proto" - throttlerdatapb "vitess.io/vitess/go/vt/proto/throttlerdata" ) @@ -225,7 +223,7 @@ func TestManager_UpdateConfiguration_ZeroValues(t *testing.T) { defer f.tearDown() // Test the explicit copy of zero values. - zeroValueConfig := proto.Clone(defaultMaxReplicationLagModuleConfig.Configuration).(*throttlerdatapb.Configuration) + zeroValueConfig := defaultMaxReplicationLagModuleConfig.Configuration.CloneVT() zeroValueConfig.IgnoreNSlowestReplicas = 0 names, err := f.m.UpdateConfiguration("t2", zeroValueConfig, true /* copyZeroValues */) if err != nil { diff --git a/go/vt/throttler/max_replication_lag_module.go b/go/vt/throttler/max_replication_lag_module.go index 5dcf9f8047b..f08c9211205 100644 --- a/go/vt/throttler/max_replication_lag_module.go +++ b/go/vt/throttler/max_replication_lag_module.go @@ -207,7 +207,7 @@ func (m *MaxReplicationLagModule) applyLatestConfig() { func (m *MaxReplicationLagModule) getConfiguration() *throttlerdatapb.Configuration { m.mutableConfigMu.Lock() defer m.mutableConfigMu.Unlock() - return proto.Clone(m.mutableConfig.Configuration).(*throttlerdatapb.Configuration) + return m.mutableConfig.Configuration.CloneVT() } func (m *MaxReplicationLagModule) updateConfiguration(configuration *throttlerdatapb.Configuration, copyZeroValues bool) error { @@ -217,7 +217,7 @@ func (m *MaxReplicationLagModule) updateConfiguration(configuration *throttlerda newConfig := m.mutableConfig if copyZeroValues { - newConfig.Configuration = proto.Clone(configuration).(*throttlerdatapb.Configuration) + newConfig.Configuration = configuration.CloneVT() } else { proto.Merge(newConfig.Configuration, configuration) } diff --git a/go/vt/throttler/max_replication_lag_module_config.go b/go/vt/throttler/max_replication_lag_module_config.go index 775aa4639a4..e61909f57dc 100644 --- a/go/vt/throttler/max_replication_lag_module_config.go +++ b/go/vt/throttler/max_replication_lag_module_config.go @@ -20,8 +20,6 @@ import ( "fmt" "time" - "google.golang.org/protobuf/proto" - throttlerdatapb "vitess.io/vitess/go/vt/proto/throttlerdata" ) @@ -33,9 +31,7 @@ type MaxReplicationLagModuleConfig struct { } func (cfg MaxReplicationLagModuleConfig) Clone() MaxReplicationLagModuleConfig { - return MaxReplicationLagModuleConfig{ - proto.Clone(cfg.Configuration).(*throttlerdatapb.Configuration), - } + return MaxReplicationLagModuleConfig{cfg.Configuration.CloneVT()} } // Most of the values are based on the assumption that vttablet is started diff --git a/go/vt/topo/helpers/copy.go b/go/vt/topo/helpers/copy.go index 5a1a5cd3465..27d39179688 100644 --- a/go/vt/topo/helpers/copy.go +++ b/go/vt/topo/helpers/copy.go @@ -101,7 +101,7 @@ func CopyShards(ctx context.Context, fromTS, toTS *topo.Server) { } } if _, err := toTS.UpdateShardFields(ctx, keyspace, shard, func(toSI *topo.ShardInfo) error { - toSI.Shard = proto.Clone(si.Shard).(*topodatapb.Shard) + toSI.Shard = si.Shard.CloneVT() return nil }); err != nil { log.Fatalf("UpdateShardFields(%v, %v): %v", keyspace, shard, err) diff --git a/go/vt/topo/shard.go b/go/vt/topo/shard.go index 87d274f60df..f0623f216d8 100644 --- a/go/vt/topo/shard.go +++ b/go/vt/topo/shard.go @@ -27,8 +27,6 @@ import ( "sync" "time" - "google.golang.org/protobuf/proto" - "vitess.io/vitess/go/constants/sidecar" "vitess.io/vitess/go/protoutil" "vitess.io/vitess/go/vt/proto/vtrpc" @@ -633,7 +631,7 @@ func (ts *Server) FindAllTabletAliasesInShardByCell(ctx context.Context, keyspac } for _, a := range resultAsMap { - result = append(result, proto.Clone(a).(*topodatapb.TabletAlias)) + result = append(result, a.CloneVT()) } sort.Sort(topoproto.TabletAliasList(result)) return result, err diff --git a/go/vt/topo/tablet.go b/go/vt/topo/tablet.go index 443ced52686..d17235f6948 100644 --- a/go/vt/topo/tablet.go +++ b/go/vt/topo/tablet.go @@ -27,15 +27,12 @@ import ( "vitess.io/vitess/go/protoutil" "vitess.io/vitess/go/vt/key" - "vitess.io/vitess/go/vt/proto/vtrpc" - "vitess.io/vitess/go/vt/vterrors" - - "google.golang.org/protobuf/proto" - "vitess.io/vitess/go/event" "vitess.io/vitess/go/netutil" "vitess.io/vitess/go/trace" "vitess.io/vitess/go/vt/log" + "vitess.io/vitess/go/vt/proto/vtrpc" + "vitess.io/vitess/go/vt/vterrors" topodatapb "vitess.io/vitess/go/vt/proto/topodata" "vitess.io/vitess/go/vt/topo/events" @@ -602,7 +599,7 @@ func (ts *Server) InitTablet(ctx context.Context, tablet *topodatapb.Tablet, all if oldTablet.Keyspace != tablet.Keyspace || oldTablet.Shard != tablet.Shard { return fmt.Errorf("old tablet has shard %v/%v. Cannot override with shard %v/%v. Delete and re-add tablet if you want to change the tablet's keyspace/shard", oldTablet.Keyspace, oldTablet.Shard, tablet.Keyspace, tablet.Shard) } - oldTablet.Tablet = proto.Clone(tablet).(*topodatapb.Tablet) + oldTablet.Tablet = tablet.CloneVT() if err := ts.UpdateTablet(ctx, oldTablet); err != nil { return fmt.Errorf("failed updating tablet %v: %v", topoproto.TabletAliasString(tablet.Alias), err) } diff --git a/go/vt/vtadmin/api_test.go b/go/vt/vtadmin/api_test.go index a93fca0bb7e..4a68abd6b73 100644 --- a/go/vt/vtadmin/api_test.go +++ b/go/vt/vtadmin/api_test.go @@ -803,8 +803,7 @@ func TestFindSchema(t *testing.T) { if schema != nil { // Clone so our mutation below doesn't trip the race detector. - schema = proto.Clone(schema).(*vtadminpb.Schema) - + schema = schema.CloneVT() for _, td := range schema.TableDefinitions { // Zero these out because they're non-deterministic and also not // relevant to the final result. @@ -1571,7 +1570,7 @@ func TestGetSchema(t *testing.T) { if resp != nil { // Clone so our mutation below doesn't trip the race detector. - resp = proto.Clone(resp).(*vtadminpb.Schema) + resp = resp.CloneVT() } assert.NoError(t, err) @@ -1729,8 +1728,7 @@ func TestGetSchema(t *testing.T) { if schema != nil { // Clone so our mutation below doesn't trip the race detector. - schema = proto.Clone(schema).(*vtadminpb.Schema) - + schema = schema.CloneVT() for _, td := range schema.TableDefinitions { // Zero these out because they're non-deterministic and also not // relevant to the final result. @@ -2538,8 +2536,7 @@ func TestGetSchemas(t *testing.T) { // Clone schemas so our mutations below don't trip the race detector. schemas := make([]*vtadminpb.Schema, len(resp.Schemas)) for i, schema := range resp.Schemas { - schema := proto.Clone(schema).(*vtadminpb.Schema) - + schema := schema.CloneVT() for _, td := range schema.TableDefinitions { // Zero these out because they're non-deterministic and also not // relevant to the final result. diff --git a/go/vt/vtadmin/cluster/cluster.go b/go/vt/vtadmin/cluster/cluster.go index e64dff7e11a..9c8a63ea930 100644 --- a/go/vt/vtadmin/cluster/cluster.go +++ b/go/vt/vtadmin/cluster/cluster.go @@ -30,8 +30,6 @@ import ( "text/template" "time" - "google.golang.org/protobuf/proto" - "vitess.io/vitess/go/pools" "vitess.io/vitess/go/protoutil" "vitess.io/vitess/go/sets" @@ -1573,8 +1571,7 @@ func (c *Cluster) getSchemaFromTablets(ctx context.Context, keyspace string, tab span, ctx := trace.NewSpan(ctx, "Vtctld.GetSchema") defer span.Finish() - - req := proto.Clone(opts.BaseRequest).(*vtctldatapb.GetSchemaRequest) + req := opts.BaseRequest.CloneVT() req.TableSizesOnly = sizesOnly req.TabletAlias = tablet.Tablet.Alias diff --git a/go/vt/vtadmin/cluster/cluster_test.go b/go/vt/vtadmin/cluster/cluster_test.go index c3b86a7526d..53c3b4f71cd 100644 --- a/go/vt/vtadmin/cluster/cluster_test.go +++ b/go/vt/vtadmin/cluster/cluster_test.go @@ -27,10 +27,8 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - "google.golang.org/protobuf/proto" "vitess.io/vitess/go/mysql/replication" - "vitess.io/vitess/go/protoutil" "vitess.io/vitess/go/sets" "vitess.io/vitess/go/test/utils" @@ -2704,8 +2702,7 @@ func TestGetSchema(t *testing.T) { } // Clone so our mutation below doesn't trip the race detector. - schema = proto.Clone(schema).(*vtadminpb.Schema) - + schema = schema.CloneVT() if schema.TableDefinitions != nil { // For simplicity, we're going to assert only on the state // of the aggregated sizes (in schema.TableSizes), since the diff --git a/go/vt/vtadmin/cluster/internal/caches/schemacache/cache.go b/go/vt/vtadmin/cluster/internal/caches/schemacache/cache.go index 98801ab3951..ebc3899e82f 100644 --- a/go/vt/vtadmin/cluster/internal/caches/schemacache/cache.go +++ b/go/vt/vtadmin/cluster/internal/caches/schemacache/cache.go @@ -22,8 +22,6 @@ import ( "fmt" "time" - "google.golang.org/protobuf/proto" - "vitess.io/vitess/go/vt/log" "vitess.io/vitess/go/vt/mysqlctl/tmutils" "vitess.io/vitess/go/vt/vtadmin/cache" @@ -178,8 +176,7 @@ func LoadOne(c *schemaCache, key Key, opts LoadOptions) (schema *vtadminpb.Schem } func loadSchema(cachedSchema *vtadminpb.Schema, opts LoadOptions) *vtadminpb.Schema { - schema := proto.Clone(cachedSchema).(*vtadminpb.Schema) - + schema := cachedSchema.CloneVT() if !opts.AggregateSizes { schema.TableSizes = nil } diff --git a/go/vt/vtctl/grpcvtctldserver/server.go b/go/vt/vtctl/grpcvtctldserver/server.go index 48edeec9dd9..788ca779701 100644 --- a/go/vt/vtctl/grpcvtctldserver/server.go +++ b/go/vt/vtctl/grpcvtctldserver/server.go @@ -31,7 +31,6 @@ import ( "golang.org/x/sync/semaphore" "google.golang.org/grpc" - "google.golang.org/protobuf/proto" "vitess.io/vitess/go/event" "vitess.io/vitess/go/netutil" @@ -571,7 +570,7 @@ func (s *VtctldServer) ChangeTabletType(ctx context.Context, req *vtctldatapb.Ch } if req.DryRun { - afterTablet := proto.Clone(tablet.Tablet).(*topodatapb.Tablet) + afterTablet := tablet.Tablet.CloneVT() afterTablet.Type = req.DbType return &vtctldatapb.ChangeTabletTypeResponse{ @@ -619,7 +618,7 @@ func (s *VtctldServer) ChangeTabletType(ctx context.Context, req *vtctldatapb.Ch // We should clone the tablet and change its type to the expected type before checking the durability rules // Since we want to check the durability rules for the desired state and not before we make that change - expectedTablet := proto.Clone(tablet.Tablet).(*topodatapb.Tablet) + expectedTablet := tablet.Tablet.CloneVT() expectedTablet.Type = req.DbType err = s.tmc.ChangeType(ctx, tablet.Tablet, req.DbType, reparentutil.IsReplicaSemiSync(durability, shardPrimary.Tablet, expectedTablet)) if err != nil { @@ -2313,7 +2312,7 @@ func (s *VtctldServer) InitShardPrimaryLocked( if !ok { return fmt.Errorf("primary-elect tablet %v is not in the shard", topoproto.TabletAliasString(req.PrimaryElectTabletAlias)) } - ev.NewPrimary = proto.Clone(primaryElectTabletInfo.Tablet).(*topodatapb.Tablet) + ev.NewPrimary = primaryElectTabletInfo.Tablet.CloneVT() // Check the primary is the only primary is the shard, or -force was used. _, primaryTabletMap := topotools.SortedTabletMap(tabletMap) @@ -3802,7 +3801,7 @@ func (s *VtctldServer) TabletExternallyReparented(ctx context.Context, req *vtct log.Infof("TabletExternallyReparented: executing tablet type change %v -> PRIMARY on %v", tablet.Type, topoproto.TabletAliasString(req.Tablet)) ev := &events.Reparent{ ShardInfo: *shard, - NewPrimary: proto.Clone(tablet.Tablet).(*topodatapb.Tablet), + NewPrimary: tablet.Tablet.CloneVT(), OldPrimary: &topodatapb.Tablet{ Alias: shard.PrimaryAlias, Type: topodatapb.TabletType_PRIMARY, @@ -3854,9 +3853,7 @@ func (s *VtctldServer) UpdateCellInfo(ctx context.Context, req *vtctldatapb.Upda var updatedCi *topodatapb.CellInfo err = s.ts.UpdateCellInfoFields(ctx, req.Name, func(ci *topodatapb.CellInfo) error { - defer func() { - updatedCi = proto.Clone(ci).(*topodatapb.CellInfo) - }() + defer func() { updatedCi = ci.CloneVT() }() changed := false @@ -3902,9 +3899,7 @@ func (s *VtctldServer) UpdateCellsAlias(ctx context.Context, req *vtctldatapb.Up var updatedCa *topodatapb.CellsAlias err = s.ts.UpdateCellsAlias(ctx, req.Name, func(ca *topodatapb.CellsAlias) error { - defer func() { - updatedCa = proto.Clone(ca).(*topodatapb.CellsAlias) - }() + defer func() { updatedCa = ca.CloneVT() }() ca.Cells = req.CellsAlias.Cells return nil diff --git a/go/vt/vtctl/grpcvtctldserver/server_test.go b/go/vt/vtctl/grpcvtctldserver/server_test.go index 9813dada377..9999cbdc5bd 100644 --- a/go/vt/vtctl/grpcvtctldserver/server_test.go +++ b/go/vt/vtctl/grpcvtctldserver/server_test.go @@ -31,7 +31,6 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - "google.golang.org/protobuf/proto" "vitess.io/vitess/go/mysql" "vitess.io/vitess/go/mysql/replication" @@ -4885,7 +4884,7 @@ func TestGetCellInfo(t *testing.T) { ServerAddress: "example.com", Root: "vitess", } - input := proto.Clone(expected).(*topodatapb.CellInfo) + input := expected.CloneVT() require.NoError(t, ts.CreateCellInfo(ctx, "cell1", input)) resp, err := vtctld.GetCellInfo(ctx, &vtctldatapb.GetCellInfoRequest{Cell: "cell1"}) @@ -4917,7 +4916,7 @@ func TestGetCellsAliases(t *testing.T) { } for i, alias := range []*topodatapb.CellsAlias{alias1, alias2} { - input := proto.Clone(alias).(*topodatapb.CellsAlias) + input := alias.CloneVT() name := fmt.Sprintf("a%d", i+1) require.NoError(t, ts.CreateCellsAlias(ctx, name, input), "cannot create cells alias %d (idx = %d) = %+v", i+1, i, input) } diff --git a/go/vt/vtctl/grpcvtctldserver/testutil/proto_compare.go b/go/vt/vtctl/grpcvtctldserver/testutil/proto_compare.go index 45692e70114..20ad0f692b0 100644 --- a/go/vt/vtctl/grpcvtctldserver/testutil/proto_compare.go +++ b/go/vt/vtctl/grpcvtctldserver/testutil/proto_compare.go @@ -23,10 +23,8 @@ import ( "testing" "github.com/stretchr/testify/assert" - "google.golang.org/protobuf/proto" "vitess.io/vitess/go/test/utils" - logutilpb "vitess.io/vitess/go/vt/proto/logutil" topodatapb "vitess.io/vitess/go/vt/proto/topodata" vtctldatapb "vitess.io/vitess/go/vt/proto/vtctldata" @@ -37,11 +35,9 @@ import ( // respective Events field in the comparison. func AssertEmergencyReparentShardResponsesEqual(t *testing.T, expected *vtctldatapb.EmergencyReparentShardResponse, actual *vtctldatapb.EmergencyReparentShardResponse, msgAndArgs ...any) { t.Helper() - - expected = proto.Clone(expected).(*vtctldatapb.EmergencyReparentShardResponse) + expected = expected.CloneVT() expected.Events = nil - - actual = proto.Clone(actual).(*vtctldatapb.EmergencyReparentShardResponse) + actual = actual.CloneVT() actual.Events = nil utils.MustMatch(t, expected, actual) @@ -104,11 +100,9 @@ func clearEvents(events []*logutilpb.Event, f func(*logutilpb.Event) *logutilpb. // respective Events field in the comparison. func AssertPlannedReparentShardResponsesEqual(t *testing.T, expected *vtctldatapb.PlannedReparentShardResponse, actual *vtctldatapb.PlannedReparentShardResponse) { t.Helper() - - expected = proto.Clone(expected).(*vtctldatapb.PlannedReparentShardResponse) + expected = expected.CloneVT() expected.Events = nil - - actual = proto.Clone(actual).(*vtctldatapb.PlannedReparentShardResponse) + actual = actual.CloneVT() actual.Events = nil utils.MustMatch(t, expected, actual) diff --git a/go/vt/vtctl/grpcvtctldserver/testutil/util.go b/go/vt/vtctl/grpcvtctldserver/testutil/util.go index 155f99fca7d..97638e9c41e 100644 --- a/go/vt/vtctl/grpcvtctldserver/testutil/util.go +++ b/go/vt/vtctl/grpcvtctldserver/testutil/util.go @@ -24,8 +24,6 @@ import ( "fmt" "testing" - "google.golang.org/protobuf/proto" - "github.com/stretchr/testify/require" "golang.org/x/net/nettest" "google.golang.org/grpc" @@ -106,7 +104,7 @@ func WithTestServers( // could not be added. It shallow copies the proto struct to prevent XXX_ fields // from changing in the marshalling. func AddKeyspace(ctx context.Context, t *testing.T, ts *topo.Server, ks *vtctldatapb.Keyspace) { - err := ts.CreateKeyspace(ctx, ks.Name, proto.Clone(ks.Keyspace).(*topodatapb.Keyspace)) + err := ts.CreateKeyspace(ctx, ks.Name, ks.Keyspace.CloneVT()) require.NoError(t, err) } @@ -150,7 +148,7 @@ type AddTabletOptions struct { // AddTablet will fail the test. func AddTablet(ctx context.Context, t *testing.T, ts *topo.Server, tablet *topodatapb.Tablet, opts *AddTabletOptions) { t.Helper() - tablet = proto.Clone(tablet).(*topodatapb.Tablet) + tablet = tablet.CloneVT() if opts == nil { opts = &AddTabletOptions{} } diff --git a/go/vt/vtctl/reparentutil/emergency_reparenter.go b/go/vt/vtctl/reparentutil/emergency_reparenter.go index 1c31372f365..13705e8fa59 100644 --- a/go/vt/vtctl/reparentutil/emergency_reparenter.go +++ b/go/vt/vtctl/reparentutil/emergency_reparenter.go @@ -22,8 +22,6 @@ import ( "sync" "time" - "google.golang.org/protobuf/proto" - "vitess.io/vitess/go/mysql/replication" "vitess.io/vitess/go/event" @@ -302,8 +300,7 @@ func (erp *EmergencyReparenter) reparentShardLocked(ctx context.Context, ev *eve if err != nil { return err } - - ev.NewPrimary = proto.Clone(newPrimary).(*topodatapb.Tablet) + ev.NewPrimary = newPrimary.CloneVT() return err } diff --git a/go/vt/vtctl/reparentutil/planned_reparenter.go b/go/vt/vtctl/reparentutil/planned_reparenter.go index 242d1e973ef..c178b64bf1d 100644 --- a/go/vt/vtctl/reparentutil/planned_reparenter.go +++ b/go/vt/vtctl/reparentutil/planned_reparenter.go @@ -23,22 +23,19 @@ import ( "time" "golang.org/x/sync/errgroup" - "google.golang.org/protobuf/proto" - - "vitess.io/vitess/go/mysql/replication" "vitess.io/vitess/go/event" + "vitess.io/vitess/go/mysql/replication" "vitess.io/vitess/go/vt/concurrency" "vitess.io/vitess/go/vt/logutil" + logutilpb "vitess.io/vitess/go/vt/proto/logutil" + topodatapb "vitess.io/vitess/go/vt/proto/topodata" + "vitess.io/vitess/go/vt/proto/vtrpc" "vitess.io/vitess/go/vt/topo" "vitess.io/vitess/go/vt/topo/topoproto" "vitess.io/vitess/go/vt/topotools/events" "vitess.io/vitess/go/vt/vterrors" "vitess.io/vitess/go/vt/vttablet/tmclient" - - logutilpb "vitess.io/vitess/go/vt/proto/logutil" - topodatapb "vitess.io/vitess/go/vt/proto/topodata" - "vitess.io/vitess/go/vt/proto/vtrpc" ) // PlannedReparenter performs PlannedReparentShard operations. @@ -200,9 +197,7 @@ func (pr *PlannedReparenter) preflightChecks( if !canEstablishForTablet(opts.durability, newPrimaryTabletInfo.Tablet, tabletsReachable) { return true, vterrors.Errorf(vtrpc.Code_FAILED_PRECONDITION, "primary-elect tablet %v won't be able to make forward progress on promotion", primaryElectAliasStr) } - - ev.NewPrimary = proto.Clone(newPrimaryTabletInfo.Tablet).(*topodatapb.Tablet) - + ev.NewPrimary = newPrimaryTabletInfo.Tablet.CloneVT() return false, nil } @@ -217,7 +212,7 @@ func (pr *PlannedReparenter) performGracefulPromotion( opts PlannedReparentOptions, ) error { primaryElectAliasStr := topoproto.TabletAliasString(primaryElect.Alias) - ev.OldPrimary = proto.Clone(currentPrimary.Tablet).(*topodatapb.Tablet) + ev.OldPrimary = currentPrimary.Tablet.CloneVT() // Before demoting the old primary, we're going to ensure that replication // is working from the old primary to the primary-elect. If replication is diff --git a/go/vt/vtctl/workflow/server.go b/go/vt/vtctl/workflow/server.go index e0eb83be15e..9d79156ae46 100644 --- a/go/vt/vtctl/workflow/server.go +++ b/go/vt/vtctl/workflow/server.go @@ -27,9 +27,7 @@ import ( "time" "golang.org/x/sync/semaphore" - "google.golang.org/protobuf/encoding/prototext" - "google.golang.org/protobuf/proto" "vitess.io/vitess/go/mysql/sqlerror" "vitess.io/vitess/go/protoutil" @@ -1023,7 +1021,7 @@ func (s *Server) MoveTablesCreate(ctx context.Context, req *vtctldatapb.MoveTabl if !vschema.Sharded { // Save the original in case we need to restore it for a late failure // in the defer(). - origVSchema = proto.Clone(vschema).(*vschemapb.Keyspace) + origVSchema = vschema.CloneVT() if err := s.addTablesToVSchema(ctx, sourceKeyspace, vschema, tables, externalTopo == nil); err != nil { return nil, err } diff --git a/go/vt/vtctl/workflow/vreplication_stream.go b/go/vt/vtctl/workflow/vreplication_stream.go index f3da6a85236..980d686bae9 100644 --- a/go/vt/vtctl/workflow/vreplication_stream.go +++ b/go/vt/vtctl/workflow/vreplication_stream.go @@ -21,8 +21,6 @@ import ( "sort" "strings" - "google.golang.org/protobuf/proto" - "vitess.io/vitess/go/mysql/replication" binlogdatapb "vitess.io/vitess/go/vt/proto/binlogdata" @@ -89,7 +87,7 @@ func (streams VReplicationStreams) Copy() VReplicationStreams { out[i] = &VReplicationStream{ ID: vrs.ID, Workflow: vrs.Workflow, - BinlogSource: proto.Clone(vrs.BinlogSource).(*binlogdatapb.BinlogSource), + BinlogSource: vrs.BinlogSource.CloneVT(), Position: vrs.Position, } } diff --git a/go/vt/vtgate/engine/aggregations.go b/go/vt/vtgate/engine/aggregations.go index fbacf3d13c5..8037dda37a9 100644 --- a/go/vt/vtgate/engine/aggregations.go +++ b/go/vt/vtgate/engine/aggregations.go @@ -20,8 +20,6 @@ import ( "fmt" "strconv" - "google.golang.org/protobuf/proto" - "vitess.io/vitess/go/mysql/collations" "vitess.io/vitess/go/slice" "vitess.io/vitess/go/sqltypes" @@ -348,9 +346,7 @@ func isComparable(typ sqltypes.Type) bool { } func newAggregation(fields []*querypb.Field, aggregates []*AggregateParams) (aggregationState, []*querypb.Field, error) { - fields = slice.Map(fields, func(from *querypb.Field) *querypb.Field { - return proto.Clone(from).(*querypb.Field) - }) + fields = slice.Map(fields, func(from *querypb.Field) *querypb.Field { return from.CloneVT() }) agstate := make([]aggregator, len(fields)) for _, aggr := range aggregates { diff --git a/go/vt/vtgate/executor_test.go b/go/vt/vtgate/executor_test.go index 2f9779b5467..17d73997125 100644 --- a/go/vt/vtgate/executor_test.go +++ b/go/vt/vtgate/executor_test.go @@ -377,7 +377,7 @@ func TestExecutorAutocommit(t *testing.T) { _, err := executor.Execute(ctx, nil, "TestExecute", session, "select id from main1", nil) require.NoError(t, err) wantSession := &vtgatepb.Session{TargetString: "@primary", InTransaction: true, FoundRows: 1, RowCount: -1} - testSession := proto.Clone(session.Session).(*vtgatepb.Session) + testSession := session.Session.CloneVT() testSession.ShardSessions = nil utils.MustMatch(t, wantSession, testSession, "session does not match for autocommit=0") @@ -418,7 +418,7 @@ func TestExecutorAutocommit(t *testing.T) { _, err = executor.Execute(ctx, nil, "TestExecute", session, "update main1 set id=1", nil) require.NoError(t, err) wantSession = &vtgatepb.Session{InTransaction: true, Autocommit: true, TargetString: "@primary", FoundRows: 0, RowCount: 1} - testSession = proto.Clone(session.Session).(*vtgatepb.Session) + testSession = session.Session.CloneVT() testSession.ShardSessions = nil utils.MustMatch(t, wantSession, testSession, "session does not match for autocommit=1") if got, want := sbclookup.CommitCount.Load(), startCount; got != want { diff --git a/go/vt/vtgate/safe_session.go b/go/vt/vtgate/safe_session.go index 46fbbea82c7..e2f3c235c94 100644 --- a/go/vt/vtgate/safe_session.go +++ b/go/vt/vtgate/safe_session.go @@ -135,7 +135,7 @@ func NewSafeSession(sessn *vtgatepb.Session) *SafeSession { // NewAutocommitSession returns a SafeSession based on the original // session, but with autocommit enabled. func NewAutocommitSession(sessn *vtgatepb.Session) *SafeSession { - newSession := proto.Clone(sessn).(*vtgatepb.Session) + newSession := sessn.CloneVT() newSession.InTransaction = false newSession.ShardSessions = nil newSession.PreSessions = nil diff --git a/go/vt/vtgate/vschema_manager.go b/go/vt/vtgate/vschema_manager.go index 6af61b154fe..3b99be052b0 100644 --- a/go/vt/vtgate/vschema_manager.go +++ b/go/vt/vtgate/vschema_manager.go @@ -20,13 +20,10 @@ import ( "context" "sync" + "vitess.io/vitess/go/vt/log" topodatapb "vitess.io/vitess/go/vt/proto/topodata" "vitess.io/vitess/go/vt/sqlparser" "vitess.io/vitess/go/vt/srvtopo" - - "google.golang.org/protobuf/proto" - - "vitess.io/vitess/go/vt/log" "vitess.io/vitess/go/vt/topo" "vitess.io/vitess/go/vt/vtgate/vindexes" @@ -58,7 +55,7 @@ type SchemaInfo interface { func (vm *VSchemaManager) GetCurrentSrvVschema() *vschemapb.SrvVSchema { vm.mu.Lock() defer vm.mu.Unlock() - return proto.Clone(vm.currentSrvVschema).(*vschemapb.SrvVSchema) + return vm.currentSrvVschema.CloneVT() } // UpdateVSchema propagates the updated vschema to the topo. The entry for diff --git a/go/vt/vtgate/vstream_manager.go b/go/vt/vtgate/vstream_manager.go index 154f23f3941..38706a8fbee 100644 --- a/go/vt/vtgate/vstream_manager.go +++ b/go/vt/vtgate/vstream_manager.go @@ -31,13 +31,10 @@ import ( "vitess.io/vitess/go/vt/servenv" "vitess.io/vitess/go/vt/topo" - vtgatepb "vitess.io/vitess/go/vt/proto/vtgate" - - "google.golang.org/protobuf/proto" - "vitess.io/vitess/go/vt/log" binlogdatapb "vitess.io/vitess/go/vt/proto/binlogdata" topodatapb "vitess.io/vitess/go/vt/proto/topodata" + vtgatepb "vitess.io/vitess/go/vt/proto/vtgate" vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc" "vitess.io/vitess/go/vt/srvtopo" "vitess.io/vitess/go/vt/vterrors" @@ -580,12 +577,12 @@ func (vs *vstream) streamFromTablet(ctx context.Context, sgtid *binlogdatapb.Sha // Update table names and send. // If we're streaming from multiple keyspaces, this will disambiguate // duplicate table names. - ev := proto.Clone(event).(*binlogdatapb.VEvent) + ev := event.CloneVT() ev.FieldEvent.TableName = sgtid.Keyspace + "." + ev.FieldEvent.TableName sendevents = append(sendevents, ev) case binlogdatapb.VEventType_ROW: // Update table names and send. - ev := proto.Clone(event).(*binlogdatapb.VEvent) + ev := event.CloneVT() ev.RowEvent.TableName = sgtid.Keyspace + "." + ev.RowEvent.TableName sendevents = append(sendevents, ev) case binlogdatapb.VEventType_COMMIT, binlogdatapb.VEventType_DDL, binlogdatapb.VEventType_OTHER: @@ -703,7 +700,7 @@ func (vs *vstream) sendAll(ctx context.Context, sgtid *binlogdatapb.ShardGtid, e sgtid.Gtid = event.Gtid events[j] = &binlogdatapb.VEvent{ Type: binlogdatapb.VEventType_VGTID, - Vgtid: proto.Clone(vs.vgtid).(*binlogdatapb.VGtid), + Vgtid: vs.vgtid.CloneVT(), Keyspace: event.Keyspace, Shard: event.Shard, } @@ -732,7 +729,7 @@ func (vs *vstream) sendAll(ctx context.Context, sgtid *binlogdatapb.ShardGtid, e } events[j] = &binlogdatapb.VEvent{ Type: binlogdatapb.VEventType_VGTID, - Vgtid: proto.Clone(vs.vgtid).(*binlogdatapb.VGtid), + Vgtid: vs.vgtid.CloneVT(), Keyspace: event.Keyspace, Shard: event.Shard, } diff --git a/go/vt/vtgate/vstream_manager_test.go b/go/vt/vtgate/vstream_manager_test.go index 32407abe472..3018791964f 100644 --- a/go/vt/vtgate/vstream_manager_test.go +++ b/go/vt/vtgate/vstream_manager_test.go @@ -1217,7 +1217,7 @@ func verifyEvents(t *testing.T, ch <-chan *binlogdatapb.VStreamResponse, wants . t.Helper() for i, want := range wants { val := <-ch - got := proto.Clone(val).(*binlogdatapb.VStreamResponse) + got := val.CloneVT() require.NotNil(t, got) for _, event := range got.Events { event.Timestamp = 0 diff --git a/go/vt/vttablet/endtoend/framework/client.go b/go/vt/vttablet/endtoend/framework/client.go index 9d3abdbbf26..4d5d8bd6a18 100644 --- a/go/vt/vttablet/endtoend/framework/client.go +++ b/go/vt/vttablet/endtoend/framework/client.go @@ -21,8 +21,6 @@ import ( "errors" "time" - "google.golang.org/protobuf/proto" - "vitess.io/vitess/go/sqltypes" "vitess.io/vitess/go/vt/callerid" "vitess.io/vitess/go/vt/vttablet/tabletserver" @@ -59,7 +57,7 @@ func NewClient() *QueryClient { // NewClientWithTabletType creates a new client for Server with the provided tablet type. func NewClientWithTabletType(tabletType topodatapb.TabletType) *QueryClient { - targetCopy := proto.Clone(Target).(*querypb.Target) + targetCopy := Target.CloneVT() targetCopy.TabletType = tabletType return &QueryClient{ ctx: callerid.NewContext( diff --git a/go/vt/vttablet/onlineddl/executor.go b/go/vt/vttablet/onlineddl/executor.go index 91f6a5823e2..a86118afdf7 100644 --- a/go/vt/vttablet/onlineddl/executor.go +++ b/go/vt/vttablet/onlineddl/executor.go @@ -35,16 +35,12 @@ import ( "time" "github.com/spf13/pflag" - - "vitess.io/vitess/go/mysql/replication" - "vitess.io/vitess/go/mysql/sqlerror" - - "google.golang.org/protobuf/proto" - "google.golang.org/protobuf/encoding/prototext" "vitess.io/vitess/go/constants/sidecar" "vitess.io/vitess/go/mysql" + "vitess.io/vitess/go/mysql/replication" + "vitess.io/vitess/go/mysql/sqlerror" "vitess.io/vitess/go/sqlescape" "vitess.io/vitess/go/sqltypes" "vitess.io/vitess/go/textutil" @@ -253,7 +249,7 @@ func NewExecutor(env tabletenv.Env, tabletAlias *topodatapb.TabletAlias, ts *top } return &Executor{ env: env, - tabletAlias: proto.Clone(tabletAlias).(*topodatapb.TabletAlias), + tabletAlias: tabletAlias.CloneVT(), pool: connpool.NewPool(env, "OnlineDDLExecutorPool", tabletenv.ConnPoolConfig{ Size: databasePoolSize, diff --git a/go/vt/vttablet/queryservice/fakes/stream_health_query_service.go b/go/vt/vttablet/queryservice/fakes/stream_health_query_service.go index 6b874f6f98f..6b430603088 100644 --- a/go/vt/vttablet/queryservice/fakes/stream_health_query_service.go +++ b/go/vt/vttablet/queryservice/fakes/stream_health_query_service.go @@ -19,8 +19,6 @@ package fakes import ( "context" - "google.golang.org/protobuf/proto" - "vitess.io/vitess/go/sqltypes" querypb "vitess.io/vitess/go/vt/proto/query" topodatapb "vitess.io/vitess/go/vt/proto/topodata" @@ -53,7 +51,7 @@ func NewStreamHealthQueryService(target *querypb.Target) *StreamHealthQueryServi return &StreamHealthQueryService{ QueryService: ErrorQueryService, healthResponses: make(chan *querypb.StreamHealthResponse, 1000), - target: proto.Clone(target).(*querypb.Target), + target: target.CloneVT(), } } @@ -81,7 +79,7 @@ func (q *StreamHealthQueryService) StreamHealth(ctx context.Context, callback fu // The response will have default values typical for a healthy tablet. func (q *StreamHealthQueryService) AddDefaultHealthResponse() { q.healthResponses <- &querypb.StreamHealthResponse{ - Target: proto.Clone(q.target).(*querypb.Target), + Target: q.target.CloneVT(), Serving: true, RealtimeStats: &querypb.RealtimeStats{ ReplicationLagSeconds: DefaultReplicationLagSeconds, @@ -93,7 +91,7 @@ func (q *StreamHealthQueryService) AddDefaultHealthResponse() { // Only "qps" is different in this message. func (q *StreamHealthQueryService) AddHealthResponseWithQPS(qps float64) { q.healthResponses <- &querypb.StreamHealthResponse{ - Target: proto.Clone(q.target).(*querypb.Target), + Target: q.target.CloneVT(), Serving: true, RealtimeStats: &querypb.RealtimeStats{ Qps: qps, @@ -106,7 +104,7 @@ func (q *StreamHealthQueryService) AddHealthResponseWithQPS(qps float64) { // buffer channel. Only "replication_lag_seconds" is different in this message. func (q *StreamHealthQueryService) AddHealthResponseWithReplicationLag(replicationLag uint32) { q.healthResponses <- &querypb.StreamHealthResponse{ - Target: proto.Clone(q.target).(*querypb.Target), + Target: q.target.CloneVT(), Serving: true, RealtimeStats: &querypb.RealtimeStats{ ReplicationLagSeconds: replicationLag, @@ -118,7 +116,7 @@ func (q *StreamHealthQueryService) AddHealthResponseWithReplicationLag(replicati // buffer channel. Only "Serving" is different in this message. func (q *StreamHealthQueryService) AddHealthResponseWithNotServing() { q.healthResponses <- &querypb.StreamHealthResponse{ - Target: proto.Clone(q.target).(*querypb.Target), + Target: q.target.CloneVT(), Serving: false, RealtimeStats: &querypb.RealtimeStats{ ReplicationLagSeconds: DefaultReplicationLagSeconds, diff --git a/go/vt/vttablet/tabletmanager/tm_state.go b/go/vt/vttablet/tabletmanager/tm_state.go index 9303c64565c..df814ba5bee 100644 --- a/go/vt/vttablet/tabletmanager/tm_state.go +++ b/go/vt/vttablet/tabletmanager/tm_state.go @@ -89,7 +89,7 @@ func newTMState(tm *TabletManager, tablet *topodatapb.Tablet) *tmState { return &tmState{ tm: tm, displayState: displayState{ - tablet: proto.Clone(tablet).(*topodatapb.Tablet), + tablet: tablet.CloneVT(), }, tablet: tablet, ctx: ctx, @@ -459,15 +459,14 @@ type displayState struct { func (ts *tmState) publishForDisplay() { ts.displayState.mu.Lock() defer ts.displayState.mu.Unlock() - - ts.displayState.tablet = proto.Clone(ts.tablet).(*topodatapb.Tablet) + ts.displayState.tablet = ts.tablet.CloneVT() ts.displayState.deniedTables = ts.deniedTables[ts.tablet.Type] } func (ts *tmState) Tablet() *topodatapb.Tablet { ts.displayState.mu.Lock() defer ts.displayState.mu.Unlock() - return proto.Clone(ts.displayState.tablet).(*topodatapb.Tablet) + return ts.displayState.tablet.CloneVT() } func (ts *tmState) DeniedTables() []string { diff --git a/go/vt/vttablet/tabletmanager/vdiff/table_differ.go b/go/vt/vttablet/tabletmanager/vdiff/table_differ.go index c2e2e787c2e..e19e5f2673c 100644 --- a/go/vt/vttablet/tabletmanager/vdiff/table_differ.go +++ b/go/vt/vttablet/tabletmanager/vdiff/table_differ.go @@ -23,17 +23,11 @@ import ( "sync" "time" - "vitess.io/vitess/go/mysql/replication" - "vitess.io/vitess/go/mysql/sqlerror" - "vitess.io/vitess/go/vt/proto/topodata" - vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc" - "vitess.io/vitess/go/vt/sqlparser" - "vitess.io/vitess/go/vt/topo" - "google.golang.org/protobuf/encoding/prototext" - "google.golang.org/protobuf/proto" "vitess.io/vitess/go/mysql/collations" + "vitess.io/vitess/go/mysql/replication" + "vitess.io/vitess/go/mysql/sqlerror" "vitess.io/vitess/go/sqltypes" "vitess.io/vitess/go/vt/binlog/binlogplayer" "vitess.io/vitess/go/vt/concurrency" @@ -42,6 +36,10 @@ import ( binlogdatapb "vitess.io/vitess/go/vt/proto/binlogdata" querypb "vitess.io/vitess/go/vt/proto/query" tabletmanagerdatapb "vitess.io/vitess/go/vt/proto/tabletmanagerdata" + "vitess.io/vitess/go/vt/proto/topodata" + vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc" + "vitess.io/vitess/go/vt/sqlparser" + "vitess.io/vitess/go/vt/topo" "vitess.io/vitess/go/vt/topo/topoproto" "vitess.io/vitess/go/vt/vterrors" "vitess.io/vitess/go/vt/vtgate/engine" @@ -376,8 +374,7 @@ func (td *tableDiffer) streamOneShard(ctx context.Context, participant *shardStr // unbuffered channels which would present a major performance bottleneck. // This need arises from the gRPC VStreamRowsResponse pooling and re-use/recycling done for // gRPCQueryClient.VStreamRows() in vttablet/grpctabletconn/conn. - vsr := proto.Clone(vsrRaw).(*binlogdatapb.VStreamRowsResponse) - + vsr := vsrRaw.CloneVT() if len(fields) == 0 { if len(vsr.Fields) == 0 { return fmt.Errorf("did not received expected fields in response %+v on tablet %v", diff --git a/go/vt/vttablet/tabletmanager/vreplication/engine.go b/go/vt/vttablet/tabletmanager/vreplication/engine.go index 592577d9d9c..8b81dd722c6 100644 --- a/go/vt/vttablet/tabletmanager/vreplication/engine.go +++ b/go/vt/vttablet/tabletmanager/vreplication/engine.go @@ -27,8 +27,6 @@ import ( "sync/atomic" "time" - "google.golang.org/protobuf/proto" - "vitess.io/vitess/go/constants/sidecar" "vitess.io/vitess/go/mysql/sqlerror" @@ -682,7 +680,7 @@ func (vre *Engine) transitionJournal(je *journalEvent) { var newids []int32 for _, shard := range shardGTIDs { sgtid := je.shardGTIDs[shard] - bls := proto.Clone(vre.controllers[refid].source).(*binlogdatapb.BinlogSource) + bls := vre.controllers[refid].source.CloneVT() bls.Keyspace, bls.Shard = sgtid.Keyspace, sgtid.Shard workflowType, _ := strconv.ParseInt(params["workflow_type"], 10, 32) diff --git a/go/vt/vttablet/tabletmanager/vreplication/replicator_plan.go b/go/vt/vttablet/tabletmanager/vreplication/replicator_plan.go index 2ce5a1b7720..63a8148eae7 100644 --- a/go/vt/vttablet/tabletmanager/vreplication/replicator_plan.go +++ b/go/vt/vttablet/tabletmanager/vreplication/replicator_plan.go @@ -22,14 +22,10 @@ import ( "sort" "strings" - "vitess.io/vitess/go/mysql/collations/charset" - "vitess.io/vitess/go/mysql/collations/colldata" - "vitess.io/vitess/go/vt/vttablet" - - "google.golang.org/protobuf/proto" - "vitess.io/vitess/go/bytes2" "vitess.io/vitess/go/mysql/collations" + "vitess.io/vitess/go/mysql/collations/charset" + "vitess.io/vitess/go/mysql/collations/colldata" vjson "vitess.io/vitess/go/mysql/json" "vitess.io/vitess/go/sqltypes" "vitess.io/vitess/go/vt/binlog/binlogplayer" @@ -39,6 +35,7 @@ import ( "vitess.io/vitess/go/vt/sqlparser" "vitess.io/vitess/go/vt/vterrors" "vitess.io/vitess/go/vt/vtgate/evalengine" + "vitess.io/vitess/go/vt/vttablet" ) // ReplicatorPlan is the execution plan for the replicator. It contains @@ -80,7 +77,7 @@ func (rp *ReplicatorPlan) buildExecutionPlan(fieldEvent *binlogdatapb.FieldEvent // bind var names. tplanv.Fields = make([]*querypb.Field, 0, len(fieldEvent.Fields)) for _, fld := range fieldEvent.Fields { - trimmed := proto.Clone(fld).(*querypb.Field) + trimmed := fld.CloneVT() trimmed.Name = strings.Trim(trimmed.Name, "`") tplanv.Fields = append(tplanv.Fields, trimmed) } diff --git a/go/vt/vttablet/tabletmanager/vreplication/vcopier.go b/go/vt/vttablet/tabletmanager/vreplication/vcopier.go index a5f580c219d..da1d8c4326a 100644 --- a/go/vt/vttablet/tabletmanager/vreplication/vcopier.go +++ b/go/vt/vttablet/tabletmanager/vreplication/vcopier.go @@ -26,11 +26,9 @@ import ( "time" "google.golang.org/protobuf/encoding/prototext" - "google.golang.org/protobuf/proto" - - "vitess.io/vitess/go/mysql/replication" "vitess.io/vitess/go/bytes2" + "vitess.io/vitess/go/mysql/replication" "vitess.io/vitess/go/pools" "vitess.io/vitess/go/sqltypes" "vitess.io/vitess/go/vt/binlog/binlogplayer" @@ -504,7 +502,7 @@ func (vc *vcopier) copyTable(ctx context.Context, tableName string, copyState ma // Clone rows, since pointer values will change while async work is // happening. Can skip this when there's no parallelism. if parallelism > 1 { - rows = proto.Clone(rows).(*binlogdatapb.VStreamRowsResponse) + rows = rows.CloneVT() } // Prepare a vcopierCopyTask for the current batch of work. diff --git a/go/vt/vttablet/tabletserver/health_streamer.go b/go/vt/vttablet/tabletserver/health_streamer.go index f73116ef5cd..3ecdc180600 100644 --- a/go/vt/vttablet/tabletserver/health_streamer.go +++ b/go/vt/vttablet/tabletserver/health_streamer.go @@ -37,18 +37,15 @@ import ( "vitess.io/vitess/go/vt/dbconfigs" - "vitess.io/vitess/go/mysql" - "vitess.io/vitess/go/vt/vttablet/tabletserver/connpool" - - "google.golang.org/protobuf/proto" - "vitess.io/vitess/go/history" + "vitess.io/vitess/go/mysql" "vitess.io/vitess/go/vt/log" querypb "vitess.io/vitess/go/vt/proto/query" topodatapb "vitess.io/vitess/go/vt/proto/topodata" vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc" "vitess.io/vitess/go/vt/vterrors" "vitess.io/vitess/go/vt/vttablet/tabletmanager/vreplication" + "vitess.io/vitess/go/vt/vttablet/tabletserver/connpool" "vitess.io/vitess/go/vt/vttablet/tabletserver/tabletenv" ) @@ -130,7 +127,7 @@ func newHealthStreamer(env tabletenv.Env, alias *topodatapb.TabletAlias, engine } func (hs *healthStreamer) InitDBConfig(target *querypb.Target, cp dbconfigs.Connector) { - hs.state.Target = proto.Clone(target).(*querypb.Target) + hs.state.Target = target.CloneVT() hs.dbConfig = cp } @@ -202,7 +199,7 @@ func (hs *healthStreamer) register() (chan *querypb.StreamHealthResponse, contex hs.clients[ch] = struct{}{} // Send the current state immediately. - ch <- proto.Clone(hs.state).(*querypb.StreamHealthResponse) + ch <- hs.state.CloneVT() return ch, hs.ctx } @@ -233,9 +230,7 @@ func (hs *healthStreamer) ChangeState(tabletType topodatapb.TabletType, ptsTimes hs.state.RealtimeStats.FilteredReplicationLagSeconds, hs.state.RealtimeStats.BinlogPlayersCount = blpFunc() hs.state.RealtimeStats.Qps = hs.stats.QPSRates.TotalRate() - - shr := proto.Clone(hs.state).(*querypb.StreamHealthResponse) - + shr := hs.state.CloneVT() hs.broadCastToClients(shr) hs.history.Add(&historyRecord{ Time: time.Now(), @@ -302,7 +297,7 @@ func (hs *healthStreamer) AppendDetails(details []*kv) []*kv { func (hs *healthStreamer) SetUnhealthyThreshold(v time.Duration) { hs.unhealthyThreshold.Store(v.Nanoseconds()) - shr := proto.Clone(hs.state).(*querypb.StreamHealthResponse) + shr := hs.state.CloneVT() for ch := range hs.clients { select { case ch <- shr: @@ -391,7 +386,7 @@ func (hs *healthStreamer) reload(full map[string]*schema.Table, created, altered hs.state.RealtimeStats.TableSchemaChanged = tables hs.state.RealtimeStats.ViewSchemaChanged = views - shr := proto.Clone(hs.state).(*querypb.StreamHealthResponse) + shr := hs.state.CloneVT() hs.broadCastToClients(shr) hs.state.RealtimeStats.TableSchemaChanged = nil hs.state.RealtimeStats.ViewSchemaChanged = nil diff --git a/go/vt/vttablet/tabletserver/query_executor.go b/go/vt/vttablet/tabletserver/query_executor.go index c11c811935d..3d1d9b4b87c 100644 --- a/go/vt/vttablet/tabletserver/query_executor.go +++ b/go/vt/vttablet/tabletserver/query_executor.go @@ -24,8 +24,6 @@ import ( "sync" "time" - "google.golang.org/protobuf/proto" - "vitess.io/vitess/go/mysql/replication" "vitess.io/vitess/go/mysql/sqlerror" @@ -223,7 +221,7 @@ func (qre *QueryExecutor) execAutocommit(f func(conn *StatefulConnection) (*sqlt if qre.options == nil { qre.options = &querypb.ExecuteOptions{} } else { - qre.options = proto.Clone(qre.options).(*querypb.ExecuteOptions) + qre.options = qre.options.CloneVT() } qre.options.TransactionIsolation = querypb.ExecuteOptions_AUTOCOMMIT diff --git a/go/vt/vttablet/tabletserver/repltracker/writer.go b/go/vt/vttablet/tabletserver/repltracker/writer.go index a5d3be84781..2b7dcd1ff2e 100644 --- a/go/vt/vttablet/tabletserver/repltracker/writer.go +++ b/go/vt/vttablet/tabletserver/repltracker/writer.go @@ -23,8 +23,6 @@ import ( "sync/atomic" "time" - "google.golang.org/protobuf/proto" - "vitess.io/vitess/go/constants/sidecar" "vitess.io/vitess/go/sqltypes" @@ -81,7 +79,7 @@ func newHeartbeatWriter(env tabletenv.Env, alias *topodatapb.TabletAlias) *heart w := &heartbeatWriter{ env: env, enabled: true, - tabletAlias: proto.Clone(alias).(*topodatapb.TabletAlias), + tabletAlias: alias.CloneVT(), now: time.Now, interval: heartbeatInterval, onDemandDuration: config.ReplicationTracker.HeartbeatOnDemandSeconds.Get(), diff --git a/go/vt/vttablet/tabletserver/state_manager.go b/go/vt/vttablet/tabletserver/state_manager.go index 39e53c8607f..2115871c6bb 100644 --- a/go/vt/vttablet/tabletserver/state_manager.go +++ b/go/vt/vttablet/tabletserver/state_manager.go @@ -24,7 +24,6 @@ import ( "time" "golang.org/x/sync/semaphore" - "google.golang.org/protobuf/proto" "vitess.io/vitess/go/timer" "vitess.io/vitess/go/vt/log" @@ -192,7 +191,7 @@ type ( // Init performs the second phase of initialization. func (sm *stateManager) Init(env tabletenv.Env, target *querypb.Target) { - sm.target = proto.Clone(target).(*querypb.Target) + sm.target = target.CloneVT() sm.transitioning = semaphore.NewWeighted(1) sm.checkMySQLThrottler = semaphore.NewWeighted(1) sm.timebombDuration = env.Config().OltpReadPool.TimeoutSeconds.Get() * 10 @@ -806,7 +805,7 @@ func (sm *stateManager) State() servingState { func (sm *stateManager) Target() *querypb.Target { sm.mu.Lock() defer sm.mu.Unlock() - return proto.Clone(sm.target).(*querypb.Target) + return sm.target.CloneVT() } // IsServingString returns the name of the current TabletServer state. diff --git a/go/vt/vttablet/tabletserver/state_manager_test.go b/go/vt/vttablet/tabletserver/state_manager_test.go index 24c500ed087..23e70a66760 100644 --- a/go/vt/vttablet/tabletserver/state_manager_test.go +++ b/go/vt/vttablet/tabletserver/state_manager_test.go @@ -521,8 +521,7 @@ func TestStateManagerValidations(t *testing.T) { defer cancel() sm := newTestStateManager(t) target := &querypb.Target{TabletType: topodatapb.TabletType_PRIMARY} - sm.target = proto.Clone(target).(*querypb.Target) - + sm.target = target.CloneVT() err := sm.StartRequest(ctx, target, false) assert.Contains(t, err.Error(), "operation not allowed") diff --git a/go/vt/vttablet/tabletserver/tabletserver.go b/go/vt/vttablet/tabletserver/tabletserver.go index 6a154fcea94..497b368d1fc 100644 --- a/go/vt/vttablet/tabletserver/tabletserver.go +++ b/go/vt/vttablet/tabletserver/tabletserver.go @@ -33,8 +33,6 @@ import ( "syscall" "time" - "google.golang.org/protobuf/proto" - "vitess.io/vitess/go/mysql/sqlerror" "vitess.io/vitess/go/acl" @@ -161,7 +159,7 @@ func NewTabletServer(ctx context.Context, name string, config *tabletenv.TabletC TruncateErrorLen: config.TruncateErrorLen, enableHotRowProtection: config.HotRowProtection.Mode != tabletenv.Disable, topoServer: topoServer, - alias: proto.Clone(alias).(*topodatapb.TabletAlias), + alias: alias.CloneVT(), } tsv.QueryTimeout.Store(config.Oltp.QueryTimeoutSeconds.Get().Nanoseconds()) @@ -266,7 +264,7 @@ func (tsv *TabletServer) InitDBConfig(target *querypb.Target, dbcfgs *dbconfigs. return vterrors.NewErrorf(vtrpcpb.Code_UNAVAILABLE, vterrors.ServerNotAvailable, "Server isn't available") } tsv.sm.Init(tsv, target) - tsv.sm.target = proto.Clone(target).(*querypb.Target) + tsv.sm.target = target.CloneVT() tsv.config.DB = dbcfgs tsv.se.InitDBConfig(tsv.config.DB.DbaWithDB()) diff --git a/go/vt/vttablet/tabletserver/txthrottler/tx_throttler.go b/go/vt/vttablet/tabletserver/txthrottler/tx_throttler.go index 923c860d184..18dede5f30a 100644 --- a/go/vt/vttablet/tabletserver/txthrottler/tx_throttler.go +++ b/go/vt/vttablet/tabletserver/txthrottler/tx_throttler.go @@ -24,8 +24,6 @@ import ( "sync" "time" - "google.golang.org/protobuf/proto" - "vitess.io/vitess/go/stats" "vitess.io/vitess/go/vt/discovery" "vitess.io/vitess/go/vt/log" @@ -217,9 +215,7 @@ func NewTxThrottler(env tabletenv.Env, topoServer *topo.Server) TxThrottler { } // InitDBConfig initializes the target parameters for the throttler. -func (t *txThrottler) InitDBConfig(target *querypb.Target) { - t.target = proto.Clone(target).(*querypb.Target) -} +func (t *txThrottler) InitDBConfig(target *querypb.Target) { t.target = target.CloneVT() } // Open opens the transaction throttler. It must be called prior to 'Throttle'. func (t *txThrottler) Open() (err error) { diff --git a/go/vt/vttablet/tabletserver/vstreamer/vstreamer.go b/go/vt/vttablet/tabletserver/vstreamer/vstreamer.go index 275805f3ec5..0e808f324ff 100644 --- a/go/vt/vttablet/tabletserver/vstreamer/vstreamer.go +++ b/go/vt/vttablet/tabletserver/vstreamer/vstreamer.go @@ -24,14 +24,12 @@ import ( "time" "google.golang.org/protobuf/encoding/prototext" - "google.golang.org/protobuf/proto" - - "vitess.io/vitess/go/mysql/replication" "vitess.io/vitess/go/constants/sidecar" "vitess.io/vitess/go/mysql" mysqlbinlog "vitess.io/vitess/go/mysql/binlog" "vitess.io/vitess/go/mysql/collations" + "vitess.io/vitess/go/mysql/replication" "vitess.io/vitess/go/sqltypes" "vitess.io/vitess/go/timer" "vitess.io/vitess/go/vt/binlog" @@ -838,7 +836,7 @@ func getFields(ctx context.Context, cp dbconfigs.Connector, table, database stri // will be modified by adding ColumnType below fieldsCopy := make([]*querypb.Field, len(fields)) for i, field := range fields { - fieldsCopy[i] = proto.Clone(field).(*querypb.Field) + fieldsCopy[i] = field.CloneVT() } extColInfos, err := getExtColInfos(ctx, cp, table, database) if err != nil { diff --git a/go/vt/vttablet/tabletservermock/controller.go b/go/vt/vttablet/tabletservermock/controller.go index e8ee4f817ac..33a6b94d327 100644 --- a/go/vt/vttablet/tabletservermock/controller.go +++ b/go/vt/vttablet/tabletservermock/controller.go @@ -22,8 +22,6 @@ import ( "sync" "time" - "google.golang.org/protobuf/proto" - "vitess.io/vitess/go/vt/dbconfigs" "vitess.io/vitess/go/vt/mysqlctl" "vitess.io/vitess/go/vt/servenv" @@ -127,8 +125,7 @@ func (tqsc *Controller) AddStatusPart() { func (tqsc *Controller) InitDBConfig(target *querypb.Target, dbcfgs *dbconfigs.DBConfigs, _ mysqlctl.MysqlDaemon) error { tqsc.mu.Lock() defer tqsc.mu.Unlock() - - tqsc.target = proto.Clone(target).(*querypb.Target) + tqsc.target = target.CloneVT() return nil } @@ -161,7 +158,7 @@ func (tqsc *Controller) IsServing() bool { func (tqsc *Controller) CurrentTarget() *querypb.Target { tqsc.mu.Lock() defer tqsc.mu.Unlock() - return proto.Clone(tqsc.target).(*querypb.Target) + return tqsc.target.CloneVT() } // IsHealthy is part of the tabletserver.Controller interface diff --git a/go/vt/wrangler/materializer.go b/go/vt/wrangler/materializer.go index 5e24f63a7f7..963b840559b 100644 --- a/go/vt/wrangler/materializer.go +++ b/go/vt/wrangler/materializer.go @@ -210,7 +210,7 @@ func (wr *Wrangler) MoveTables(ctx context.Context, workflow, sourceKeyspace, ta if !vschema.Sharded { // Save the original in case we need to restore it for a late failure // in the defer(). - origVSchema = proto.Clone(vschema).(*vschemapb.Keyspace) + origVSchema = vschema.CloneVT() if err := wr.addTablesToVSchema(ctx, sourceKeyspace, vschema, tables, externalTopo == nil); err != nil { return err } diff --git a/go/vt/wrangler/tablet.go b/go/vt/wrangler/tablet.go index d52a1676e97..17c547ade58 100644 --- a/go/vt/wrangler/tablet.go +++ b/go/vt/wrangler/tablet.go @@ -21,8 +21,6 @@ import ( "fmt" "time" - "google.golang.org/protobuf/proto" - "vitess.io/vitess/go/vt/topo" "vitess.io/vitess/go/vt/topo/topoproto" "vitess.io/vitess/go/vt/topotools" @@ -105,7 +103,7 @@ func (wr *Wrangler) ChangeTabletType(ctx context.Context, tabletAlias *topodatap // We should clone the tablet and change its type to the expected type before checking the durability rules // Since we want to check the durability rules for the desired state and not before we make that change - expectedTablet := proto.Clone(ti.Tablet).(*topodatapb.Tablet) + expectedTablet := ti.Tablet.CloneVT() expectedTablet.Type = tabletType semiSync, err := wr.shouldSendSemiSyncAck(ctx, expectedTablet) if err != nil { diff --git a/go/vt/wrangler/traffic_switcher_env_test.go b/go/vt/wrangler/traffic_switcher_env_test.go index fb6d2c9fc58..c8ec71dba96 100644 --- a/go/vt/wrangler/traffic_switcher_env_test.go +++ b/go/vt/wrangler/traffic_switcher_env_test.go @@ -26,11 +26,9 @@ import ( "github.com/stretchr/testify/require" "golang.org/x/sync/semaphore" - "google.golang.org/protobuf/proto" - - "vitess.io/vitess/go/mysql/replication" "vitess.io/vitess/go/mysql/fakesqldb" + "vitess.io/vitess/go/mysql/replication" "vitess.io/vitess/go/sqlescape" "vitess.io/vitess/go/sqltypes" "vitess.io/vitess/go/vt/binlog/binlogplayer" @@ -236,7 +234,7 @@ func newTestTableMigraterCustom(ctx context.Context, t *testing.T, sourceShards, } // Now use these sequence tables in the target sharded keyspace. - tks := proto.Clone(vs).(*vschemapb.Keyspace) + tks := vs.CloneVT() tks.Tables["t1"].AutoIncrement = &vschemapb.AutoIncrement{ Column: "id", Sequence: "t1_seq", From 5d0a5a687185a50651cbf023a2ab2aaef1b641ac Mon Sep 17 00:00:00 2001 From: Vicent Marti Date: Tue, 5 Sep 2023 12:10:13 +0200 Subject: [PATCH 5/5] vstreamer: fix fields reuse Signed-off-by: Vicent Marti --- .../vttablet/tabletmanager/vdiff/table_differ.go | 2 +- .../tabletmanager/vreplication/vcopier.go | 8 ++++++-- go/vt/vttablet/tabletserver/vstreamer/copy.go | 16 ++++++++++++---- .../tabletserver/vstreamer/planbuilder.go | 2 +- 4 files changed, 20 insertions(+), 8 deletions(-) diff --git a/go/vt/vttablet/tabletmanager/vdiff/table_differ.go b/go/vt/vttablet/tabletmanager/vdiff/table_differ.go index e19e5f2673c..3752829b898 100644 --- a/go/vt/vttablet/tabletmanager/vdiff/table_differ.go +++ b/go/vt/vttablet/tabletmanager/vdiff/table_differ.go @@ -393,7 +393,7 @@ func (td *tableDiffer) streamOneShard(ctx context.Context, participant *shardStr result := sqltypes.Proto3ToResult(p3qr) // Fields should be received only once, and sent only once. - if vsr.Fields == nil { + if len(vsr.Fields) == 0 { result.Fields = nil } select { diff --git a/go/vt/vttablet/tabletmanager/vreplication/vcopier.go b/go/vt/vttablet/tabletmanager/vreplication/vcopier.go index da1d8c4326a..e5db95a795a 100644 --- a/go/vt/vttablet/tabletmanager/vreplication/vcopier.go +++ b/go/vt/vttablet/tabletmanager/vreplication/vcopier.go @@ -481,12 +481,16 @@ func (vc *vcopier) copyTable(ctx context.Context, tableName string, copyState ma fieldEvent := &binlogdatapb.FieldEvent{ TableName: initialPlan.SendRule.Match, } - fieldEvent.Fields = append(fieldEvent.Fields, rows.Fields...) + for _, f := range rows.Fields { + fieldEvent.Fields = append(fieldEvent.Fields, f.CloneVT()) + } tablePlan, err := plan.buildExecutionPlan(fieldEvent) if err != nil { return err } - pkfields = append(pkfields, rows.Pkfields...) + for _, f := range rows.Pkfields { + pkfields = append(pkfields, f.CloneVT()) + } buf := sqlparser.NewTrackedBuffer(nil) buf.Myprintf( "insert into _vt.copy_state (lastpk, vrepl_id, table_name) values (%a, %s, %s)", ":lastpk", diff --git a/go/vt/vttablet/tabletserver/vstreamer/copy.go b/go/vt/vttablet/tabletserver/vstreamer/copy.go index be2063ba0ce..585be09dec3 100644 --- a/go/vt/vttablet/tabletserver/vstreamer/copy.go +++ b/go/vt/vttablet/tabletserver/vstreamer/copy.go @@ -24,6 +24,7 @@ import ( "time" "vitess.io/vitess/go/mysql/replication" + "vitess.io/vitess/go/slice" "vitess.io/vitess/go/sqltypes" "vitess.io/vitess/go/vt/log" binlogdatapb "vitess.io/vitess/go/vt/proto/binlogdata" @@ -243,14 +244,21 @@ func (uvs *uvstreamer) copyTable(ctx context.Context, tableName string) error { log.V(2).Infof("Not starting fastforward pos is %s, uvs.pos is %s, rows.gtid %s", pos, uvs.pos, rows.Gtid) } + // Store a copy of the fields and pkfields because the original will be cleared + // when GRPC returns our request to the pool + uvs.fields = slice.Map(rows.Fields, func(f *querypb.Field) *querypb.Field { + return f.CloneVT() + }) + uvs.pkfields = slice.Map(rows.Pkfields, func(f *querypb.Field) *querypb.Field { + return f.CloneVT() + }) + fieldEvent := &binlogdatapb.FieldEvent{ TableName: tableName, - Fields: rows.Fields, + Fields: uvs.fields, Keyspace: uvs.vse.keyspace, Shard: uvs.vse.shard, } - uvs.fields = rows.Fields - uvs.pkfields = rows.Pkfields if err := uvs.sendFieldEvent(ctx, rows.Gtid, fieldEvent); err != nil { log.Infof("sendFieldEvent returned error %v", err) return err @@ -277,7 +285,7 @@ func (uvs *uvstreamer) copyTable(ctx context.Context, tableName string) error { newLastPK = sqltypes.CustomProto3ToResult(uvs.pkfields, &querypb.QueryResult{ Fields: uvs.pkfields, - Rows: []*querypb.Row{rows.Lastpk}, + Rows: []*querypb.Row{rows.Lastpk.CloneVT()}, }) qrLastPK := sqltypes.ResultToProto3(newLastPK) log.V(2).Infof("Calling sendEventForRows with gtid %s", rows.Gtid) diff --git a/go/vt/vttablet/tabletserver/vstreamer/planbuilder.go b/go/vt/vttablet/tabletserver/vstreamer/planbuilder.go index 07f0a981dd0..e270dc3d0f1 100644 --- a/go/vt/vttablet/tabletserver/vstreamer/planbuilder.go +++ b/go/vt/vttablet/tabletserver/vstreamer/planbuilder.go @@ -135,7 +135,7 @@ func (ta *Table) FindColumn(name sqlparser.IdentifierCI) int { func (plan *Plan) fields() []*querypb.Field { fields := make([]*querypb.Field, len(plan.ColExprs)) for i, ce := range plan.ColExprs { - fields[i] = ce.Field + fields[i] = ce.Field.CloneVT() } return fields }