diff --git a/go.mod b/go.mod
index 7800ba383403770c4c66e3811a616f1435c3bfee..78ec04e36a5c9c68c5828a0804e90eb3471a6927 100644
--- a/go.mod
+++ b/go.mod
@@ -124,7 +124,7 @@ require (
github.com/tklauser/numcpus v0.4.0 // indirect
github.com/yusufpapurcu/wmi v1.2.2 // indirect
go.uber.org/atomic v1.9.0 // indirect
- go.uber.org/multierr v1.8.0 // indirect
+ go.uber.org/multierr v1.8.0
golang.org/x/crypto v0.0.0-20220214200702-86341886e292 // indirect
golang.org/x/exp v0.0.0-20220414153411-bcd21879b8fd
golang.org/x/net v0.0.0-20211216030914-fe4d6282115f // indirect
diff --git a/pkg/dnservice/cfg.go b/pkg/dnservice/cfg.go
new file mode 100644
index 0000000000000000000000000000000000000000..c52531c055c5dc02caacd7b7b959c50a3cf03742
--- /dev/null
+++ b/pkg/dnservice/cfg.go
@@ -0,0 +1,201 @@
+// Copyright 2021 - 2022 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package dnservice
+
+import (
+ "fmt"
+ "strings"
+ "time"
+
+ "github.com/matrixorigin/matrixone/pkg/fileservice"
+ "github.com/matrixorigin/matrixone/pkg/logservice"
+ "github.com/matrixorigin/matrixone/pkg/util/toml"
+)
+
+var (
+ defaultListenAddress = "unix:///tmp/dn.sock"
+ defaultMaxConnections = 400
+ defaultSendQueueSize = 10240
+ defaultMaxClockOffset = time.Millisecond * 500
+ defaultZombieTimeout = time.Hour
+ defaultDiscoveryTimeout = time.Second * 30
+ defaultHeatbeatDuration = time.Second
+ defaultConnectTimeout = time.Second * 30
+ defaultHeatbeatTimeout = time.Millisecond * 500
+ defaultBufferSize = 1024
+)
+
+// Config dn store configuration
+type Config struct {
+ // UUID dn store uuid
+ UUID string `toml:"uuid"`
+ // DataDir storage directory for local data. Include DNShard metadata and TAE data.
+ DataDir string `toml:"data-dir"`
+ // ListenAddress listening address for receiving external requests.
+ ListenAddress string `toml:"listen-address"`
+ // ServiceAddress service address for communication, if this address is not set, use
+ // ListenAddress as the communication address.
+ ServiceAddress string `toml:"service-address"`
+
+ // HAKeeper configuration
+ HAKeeper struct {
+ // HeatbeatDuration heartbeat duration to send message to hakeeper. Default is 1s
+ HeatbeatDuration toml.Duration `toml:"hakeeper-heartbeat-duration"`
+ // HeatbeatTimeout heartbeat request timeout. Default is 500ms
+ HeatbeatTimeout toml.Duration `toml:"hakeeper-heartbeat-timeout"`
+ // DiscoveryTimeout discovery HAKeeper service timeout. Default is 30s
+ DiscoveryTimeout toml.Duration `toml:"hakeeper-discovery-timeout"`
+ // ClientConfig hakeeper client configuration
+ ClientConfig logservice.HAKeeperClientConfig `toml:"hakeeper-client"`
+ }
+
+ // LogService log service configuration
+ LogService struct {
+ // ConnectTimeout timeout for connect to logservice. Default is 30s.
+ ConnectTimeout toml.Duration `toml:"connect-timeout"`
+ }
+
+ // FileService file service configuration
+ FileService struct {
+ // Backend file service backend implementation. [Mem|DISK|S3|MINIO]. Default is DISK.
+ Backend string `toml:"backend"`
+ // S3 s3 configuration
+ S3 fileservice.S3Config `toml:"s3"`
+ }
+
+ // RPC configuration
+ RPC struct {
+ // MaxConnections maximum number of connections to communicate with each DNStore.
+ // Default is 400.
+ MaxConnections int `toml:"max-connections"`
+ // SendQueueSize maximum capacity of the send request queue per connection, when the
+ // queue is full, the send request will be blocked. Default is 10240.
+ SendQueueSize int `toml:"send-queue-size"`
+ // BusyQueueSize when the length of the send queue reaches the currently set value, the
+ // current connection is busy with high load. When any connection with Busy status exists,
+ // a new connection will be created until the value set by MaxConnections is reached.
+ // Default is 3/4 of SendQueueSize.
+ BusyQueueSize int `toml:"busy-queue-size"`
+ // WriteBufferSize buffer size for write messages per connection. Default is 1kb
+ WriteBufferSize toml.ByteSize `toml:"send-buffer-size"`
+ // ReadBufferSize buffer size for read messages per connection. Default is 1kb
+ ReadBufferSize toml.ByteSize `toml:"send-buffer-size"`
+ }
+
+ // Txn transactions configuration
+ Txn struct {
+ // ZombieTimeout A transaction timeout, if an active transaction has not operated for more
+ // than the specified time, it will be considered a zombie transaction and the backend will
+ // roll back the transaction.
+ ZombieTimeout toml.Duration `toml:"zombie-timeout"`
+
+ // Storage txn storage config
+ Storage struct {
+ // Backend txn storage backend implementation. [TAE|Mem], default TAE.
+ Backend string `toml:"backend"`
+
+ // TAE tae storage configuration
+ TAE struct {
+ }
+
+ // Mem mem storage configuration
+ Mem struct {
+ }
+ }
+
+ // Clock txn clock type. [LOCAL|HLC]. Default is LOCAL.
+ Clock struct {
+ // Backend clock backend implementation. [LOCAL|HLC], default LOCAL.
+ Backend string `toml:"source"`
+ // MaxClockOffset max clock offset between two nodes. Default is 500ms
+ MaxClockOffset toml.Duration `toml:"max-clock-offset"`
+ }
+ }
+}
+
+func (c *Config) validate() error {
+ if c.UUID == "" {
+ return fmt.Errorf("Config.UUID not set")
+ }
+ if c.DataDir == "" {
+ return fmt.Errorf("Config.DataDir not set")
+ }
+ if c.ListenAddress == "" {
+ c.ListenAddress = defaultListenAddress
+ }
+ if c.ServiceAddress == "" {
+ c.ServiceAddress = c.ListenAddress
+ }
+ if c.RPC.MaxConnections == 0 {
+ c.RPC.MaxConnections = defaultMaxConnections
+ }
+ if c.RPC.SendQueueSize == 0 {
+ c.RPC.SendQueueSize = defaultSendQueueSize
+ }
+ if c.RPC.BusyQueueSize == 0 {
+ c.RPC.BusyQueueSize = c.RPC.SendQueueSize * 3 / 4
+ }
+ if c.RPC.WriteBufferSize == 0 {
+ c.RPC.WriteBufferSize = toml.ByteSize(defaultBufferSize)
+ }
+ if c.RPC.ReadBufferSize == 0 {
+ c.RPC.ReadBufferSize = toml.ByteSize(defaultBufferSize)
+ }
+ if c.Txn.Clock.MaxClockOffset.Duration == 0 {
+ c.Txn.Clock.MaxClockOffset.Duration = defaultMaxClockOffset
+ }
+ if c.Txn.Clock.Backend == "" {
+ c.Txn.Clock.Backend = localClockBackend
+ }
+ if _, ok := supportTxnClockBackends[strings.ToUpper(c.Txn.Clock.Backend)]; !ok {
+ return fmt.Errorf("%s clock backend not support", c.Txn.Storage)
+ }
+ if c.Txn.Storage.Backend == "" {
+ c.Txn.Storage.Backend = taeStorageBackend
+ }
+ if _, ok := supportTxnStorageBackends[strings.ToUpper(c.Txn.Storage.Backend)]; !ok {
+ return fmt.Errorf("%s txn storage backend not support", c.Txn.Storage)
+ }
+ if c.Txn.ZombieTimeout.Duration == 0 {
+ c.Txn.ZombieTimeout.Duration = defaultZombieTimeout
+ }
+ if c.HAKeeper.DiscoveryTimeout.Duration == 0 {
+ c.HAKeeper.DiscoveryTimeout.Duration = defaultDiscoveryTimeout
+ }
+ if c.HAKeeper.HeatbeatDuration.Duration == 0 {
+ c.HAKeeper.HeatbeatDuration.Duration = defaultHeatbeatDuration
+ }
+ if c.HAKeeper.HeatbeatTimeout.Duration == 0 {
+ c.HAKeeper.HeatbeatTimeout.Duration = defaultHeatbeatTimeout
+ }
+ if c.LogService.ConnectTimeout.Duration == 0 {
+ c.LogService.ConnectTimeout.Duration = defaultConnectTimeout
+ }
+ if c.FileService.Backend == "" {
+ c.FileService.Backend = diskFileServiceBackend
+ }
+ if _, ok := supportFileServiceBackends[strings.ToUpper(c.FileService.Backend)]; !ok {
+ return fmt.Errorf("%s file service backend not support", c.Txn.Storage)
+ }
+ return nil
+}
+
+func (c Config) getMetadataDir() string {
+ return fmt.Sprintf("%s/metadata", c.DataDir)
+}
+
+func (c Config) getDataDir() string {
+ return fmt.Sprintf("%s/data", c.DataDir)
+}
diff --git a/pkg/dnservice/cfg_test.go b/pkg/dnservice/cfg_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..782ae0a734126a44f7c5ac90934f3e77e0749163
--- /dev/null
+++ b/pkg/dnservice/cfg_test.go
@@ -0,0 +1,46 @@
+// Copyright 2021 - 2022 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package dnservice
+
+import (
+ "testing"
+
+ "github.com/matrixorigin/matrixone/pkg/util/toml"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestValidate(t *testing.T) {
+ c := &Config{}
+ assert.Error(t, c.validate())
+ c.UUID = "dn1"
+ assert.Error(t, c.validate())
+ c.DataDir = "/tmp"
+ assert.NoError(t, c.validate())
+
+ assert.Equal(t, defaultListenAddress, c.ListenAddress)
+ assert.Equal(t, c.ListenAddress, c.ServiceAddress)
+ assert.Equal(t, defaultMaxConnections, c.RPC.MaxConnections)
+ assert.Equal(t, defaultSendQueueSize, c.RPC.SendQueueSize)
+ assert.Equal(t, toml.ByteSize(defaultBufferSize), c.RPC.WriteBufferSize)
+ assert.Equal(t, toml.ByteSize(defaultBufferSize), c.RPC.ReadBufferSize)
+ assert.Equal(t, defaultMaxClockOffset, c.Txn.Clock.MaxClockOffset.Duration)
+ assert.Equal(t, localClockBackend, c.Txn.Clock.Backend)
+ assert.Equal(t, taeStorageBackend, c.Txn.Storage.Backend)
+ assert.Equal(t, defaultZombieTimeout, c.Txn.ZombieTimeout.Duration)
+ assert.Equal(t, defaultDiscoveryTimeout, c.HAKeeper.DiscoveryTimeout.Duration)
+ assert.Equal(t, defaultHeatbeatDuration, c.HAKeeper.HeatbeatDuration.Duration)
+ assert.Equal(t, defaultHeatbeatTimeout, c.HAKeeper.HeatbeatTimeout.Duration)
+ assert.Equal(t, defaultConnectTimeout, c.LogService.ConnectTimeout.Duration)
+}
diff --git a/pkg/dnservice/factory.go b/pkg/dnservice/factory.go
new file mode 100644
index 0000000000000000000000000000000000000000..20e13d05de72e1e97e68b1dc0c48a91e2e91b409
--- /dev/null
+++ b/pkg/dnservice/factory.go
@@ -0,0 +1,140 @@
+// Copyright 2021 - 2022 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package dnservice
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/matrixorigin/matrixone/pkg/fileservice"
+ "github.com/matrixorigin/matrixone/pkg/logservice"
+ "github.com/matrixorigin/matrixone/pkg/pb/metadata"
+ "github.com/matrixorigin/matrixone/pkg/txn/clock"
+ "github.com/matrixorigin/matrixone/pkg/txn/storage"
+ "github.com/matrixorigin/matrixone/pkg/txn/storage/mem"
+)
+
+const (
+ memStorageBackend = "MEM"
+ taeStorageBackend = "TAE"
+
+ localClockBackend = "LOCAL"
+ hlcClockBackend = "HLC"
+
+ memFileServiceBackend = "MEM"
+ diskFileServiceBackend = "DISK"
+ s3FileServiceBackend = "S3"
+ minioFileServiceBackend = "MINIO"
+)
+
+var (
+ supportTxnStorageBackends = map[string]struct{}{
+ memStorageBackend: {},
+ taeStorageBackend: {},
+ }
+
+ supportTxnClockBackends = map[string]struct{}{
+ localClockBackend: {},
+ hlcClockBackend: {},
+ }
+
+ supportFileServiceBackends = map[string]struct{}{
+ memFileServiceBackend: {},
+ diskFileServiceBackend: {},
+ s3FileServiceBackend: {},
+ minioFileServiceBackend: {},
+ }
+)
+
+func (s *store) createClock() (clock.Clock, error) {
+ switch s.cfg.Txn.Clock.Backend {
+ case localClockBackend:
+ return s.newLocalClock(), nil
+ default:
+ return nil, fmt.Errorf("not implment for %s", s.cfg.Txn.Clock.Backend)
+ }
+}
+
+func (s *store) createTxnStorage(shard metadata.DNShard) (storage.TxnStorage, error) {
+ logClient, err := s.createLogServiceClient(shard)
+ if err != nil {
+ return nil, err
+ }
+
+ switch s.cfg.Txn.Storage.Backend {
+ case memStorageBackend:
+ return s.newMemTxnStorage(shard, logClient)
+ default:
+ return nil, fmt.Errorf("not implment for %s", s.cfg.Txn.Storage.Backend)
+ }
+}
+
+func (s *store) createLogServiceClient(shard metadata.DNShard) (logservice.Client, error) {
+ if s.options.logServiceClientFactory != nil {
+ return s.options.logServiceClientFactory(shard)
+ }
+ return s.newLogServiceClient(shard)
+}
+
+func (s *store) createFileService() (fileservice.FileService, error) {
+ switch s.cfg.FileService.Backend {
+ case memFileServiceBackend:
+ return s.newMemFileService()
+ case diskFileServiceBackend:
+ return s.newDiskFileService()
+ case minioFileServiceBackend:
+ return s.newMinioFileService()
+ case s3FileServiceBackend:
+ return s.newS3FileService()
+ default:
+ return nil, fmt.Errorf("not implment for %s", s.cfg.FileService.Backend)
+ }
+}
+
+func (s *store) newLogServiceClient(shard metadata.DNShard) (logservice.Client, error) {
+ ctx, cancel := context.WithTimeout(context.Background(), s.cfg.LogService.ConnectTimeout.Duration)
+ defer cancel()
+ return logservice.NewClient(ctx, logservice.ClientConfig{
+ ReadOnly: false,
+ LogShardID: shard.LogShardID,
+ DNReplicaID: shard.ReplicaID,
+ })
+}
+
+func (s *store) newLocalClock() clock.Clock {
+ return clock.NewUnixNanoHLCClockWithStopper(s.stopper, s.cfg.Txn.Clock.MaxClockOffset.Duration)
+}
+
+func (s *store) newMemTxnStorage(shard metadata.DNShard, logClient logservice.Client) (storage.TxnStorage, error) {
+ return mem.NewKVTxnStorage(0, logClient), nil
+}
+
+func (s *store) newMemFileService() (fileservice.FileService, error) {
+ return fileservice.NewMemoryFS()
+}
+
+func (s *store) newDiskFileService() (fileservice.FileService, error) {
+ return fileservice.NewLocalFS(s.cfg.getDataDir())
+}
+
+func (s *store) newMinioFileService() (fileservice.FileService, error) {
+ return fileservice.NewS3FSMinio(s.cfg.FileService.S3)
+}
+
+func (s *store) newS3FileService() (fileservice.FileService, error) {
+ return fileservice.NewS3FS(s.cfg.FileService.S3.Endpoint,
+ s.cfg.FileService.S3.Bucket,
+ s.cfg.FileService.S3.KeyPrefix)
+}
diff --git a/pkg/dnservice/factory_test.go b/pkg/dnservice/factory_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..901bec4992369e10e5b3c60ce5c94982ac44ae1b
--- /dev/null
+++ b/pkg/dnservice/factory_test.go
@@ -0,0 +1,81 @@
+// Copyright 2021 - 2022 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package dnservice
+
+import (
+ "testing"
+
+ "github.com/matrixorigin/matrixone/pkg/common/stopper"
+ "github.com/matrixorigin/matrixone/pkg/logservice"
+ "github.com/matrixorigin/matrixone/pkg/pb/metadata"
+ "github.com/matrixorigin/matrixone/pkg/txn/storage/mem"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestCreateClock(t *testing.T) {
+ s := &store{cfg: &Config{}, stopper: stopper.NewStopper("")}
+
+ s.cfg.Txn.Clock.Backend = localClockBackend
+ s.cfg.Txn.Clock.MaxClockOffset.Duration = defaultMaxClockOffset
+ v, err := s.createClock()
+ assert.NoError(t, err)
+ assert.NotNil(t, v)
+
+ s.cfg.Txn.Clock.Backend = "error"
+ v, err = s.createClock()
+ assert.Error(t, err)
+ assert.Nil(t, v)
+}
+
+func TestCreateLogServiceClient(t *testing.T) {
+ s := &store{cfg: &Config{}, stopper: stopper.NewStopper("")}
+ s.options.logServiceClientFactory = func(d metadata.DNShard) (logservice.Client, error) {
+ return mem.NewMemLog(), nil
+ }
+ v, err := s.createLogServiceClient(metadata.DNShard{})
+ assert.NoError(t, err)
+ assert.NotNil(t, v)
+}
+
+func TestCreateFileService(t *testing.T) {
+ s := &store{cfg: &Config{}, stopper: stopper.NewStopper("")}
+
+ s.cfg.FileService.Backend = memFileServiceBackend
+ v, err := s.createFileService()
+ assert.NoError(t, err)
+ assert.NotNil(t, v)
+
+ s.cfg.FileService.Backend = "error"
+ v, err = s.createFileService()
+ assert.Error(t, err)
+ assert.Nil(t, v)
+}
+
+func TestCreateTxnStorage(t *testing.T) {
+ s := &store{cfg: &Config{}, stopper: stopper.NewStopper("")}
+ s.options.logServiceClientFactory = func(d metadata.DNShard) (logservice.Client, error) {
+ return mem.NewMemLog(), nil
+ }
+
+ s.cfg.Txn.Storage.Backend = memStorageBackend
+ v, err := s.createTxnStorage(metadata.DNShard{})
+ assert.NoError(t, err)
+ assert.NotNil(t, v)
+
+ s.cfg.Txn.Storage.Backend = "error"
+ v, err = s.createTxnStorage(metadata.DNShard{})
+ assert.Error(t, err)
+ assert.Nil(t, v)
+}
diff --git a/pkg/dnservice/replica.go b/pkg/dnservice/replica.go
new file mode 100644
index 0000000000000000000000000000000000000000..5f79890d6daeffc0159b99100d9e1aeeb4cd37a5
--- /dev/null
+++ b/pkg/dnservice/replica.go
@@ -0,0 +1,75 @@
+// Copyright 2021 - 2022 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package dnservice
+
+import (
+ "context"
+
+ "github.com/matrixorigin/matrixone/pkg/logutil"
+ "github.com/matrixorigin/matrixone/pkg/pb/metadata"
+ "github.com/matrixorigin/matrixone/pkg/pb/txn"
+ "github.com/matrixorigin/matrixone/pkg/txn/service"
+ "github.com/matrixorigin/matrixone/pkg/txn/util"
+ "go.uber.org/zap"
+)
+
+// replica dn shard replica.
+type replica struct {
+ logger *zap.Logger
+ shard metadata.DNShard
+ service service.TxnService
+ startedC chan struct{}
+}
+
+func newReplica(shard metadata.DNShard, logger *zap.Logger) *replica {
+ return &replica{
+ shard: shard,
+ logger: logutil.Adjust(logger).With(util.TxnDNShardField(shard)),
+ startedC: make(chan struct{}),
+ }
+}
+
+func (r *replica) start(txnService service.TxnService) error {
+ defer close(r.startedC)
+ r.service = txnService
+ return r.service.Start()
+}
+
+func (r *replica) close() error {
+ r.waitStarted()
+ return r.service.Close()
+}
+
+func (r *replica) handleLocalRequest(ctx context.Context, request *txn.TxnRequest, response *txn.TxnResponse) error {
+ r.waitStarted()
+ prepareResponse(request, response)
+
+ switch request.Method {
+ case txn.TxnMethod_GetStatus:
+ return r.service.GetStatus(ctx, request, response)
+ case txn.TxnMethod_Prepare:
+ return r.service.Prepare(ctx, request, response)
+ case txn.TxnMethod_CommitDNShard:
+ return r.service.CommitDNShard(ctx, request, response)
+ case txn.TxnMethod_RollbackDNShard:
+ return r.service.RollbackDNShard(ctx, request, response)
+ default:
+ panic("cannot handle local CN request")
+ }
+}
+
+func (r *replica) waitStarted() {
+ <-r.startedC
+}
diff --git a/pkg/dnservice/replica_test.go b/pkg/dnservice/replica_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..4fd12ba1521302b2328a2fcd3c993f89c10f2c2f
--- /dev/null
+++ b/pkg/dnservice/replica_test.go
@@ -0,0 +1,81 @@
+// Copyright 2021 - 2022 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package dnservice
+
+import (
+ "context"
+ "testing"
+ "time"
+
+ "github.com/matrixorigin/matrixone/pkg/pb/txn"
+ "github.com/matrixorigin/matrixone/pkg/txn/service"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestNewReplica(t *testing.T) {
+ r := newReplica(newTestDNShard(1, 2, 3), nil)
+ select {
+ case <-r.startedC:
+ assert.Fail(t, "cannot started")
+ default:
+ }
+}
+
+func TestWaitStarted(t *testing.T) {
+ r := newReplica(newTestDNShard(1, 2, 3), nil)
+ c := make(chan struct{})
+ go func() {
+ r.waitStarted()
+ c <- struct{}{}
+ }()
+
+ ts := service.NewTestTxnService(t, 1, service.NewTestSender(), service.NewTestClock(1))
+ defer func() {
+ assert.NoError(t, ts.Close())
+ }()
+
+ assert.NoError(t, r.start(ts))
+ defer func() {
+ assert.NoError(t, r.close())
+ }()
+ select {
+ case <-c:
+ case <-time.After(time.Minute):
+ assert.Fail(t, "wait started failed")
+ }
+}
+
+func TestHandleLocalCNRequestsWillPanic(t *testing.T) {
+ defer func() {
+ if err := recover(); err != nil {
+ return
+ }
+ assert.Fail(t, "must panic")
+ }()
+
+ r := newReplica(newTestDNShard(1, 2, 3), nil)
+ ts := service.NewTestTxnService(t, 1, service.NewTestSender(), service.NewTestClock(1))
+ defer func() {
+ assert.NoError(t, ts.Close())
+ }()
+
+ assert.NoError(t, r.start(ts))
+ defer func() {
+ assert.NoError(t, r.close())
+ }()
+
+ req := service.NewTestReadRequest(1, txn.TxnMeta{}, 1)
+ assert.NoError(t, r.handleLocalRequest(context.Background(), &req, &txn.TxnResponse{}))
+}
diff --git a/pkg/dnservice/store.go b/pkg/dnservice/store.go
new file mode 100644
index 0000000000000000000000000000000000000000..fbd17aa96854f09f8b131c1a331ab6aa157554e0
--- /dev/null
+++ b/pkg/dnservice/store.go
@@ -0,0 +1,410 @@
+// Copyright 2021 - 2022 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package dnservice
+
+import (
+ "context"
+ "sync"
+ "time"
+
+ "github.com/fagongzi/goetty/v2"
+ "github.com/matrixorigin/matrixone/pkg/common/morpc"
+ "github.com/matrixorigin/matrixone/pkg/common/stopper"
+ "github.com/matrixorigin/matrixone/pkg/fileservice"
+ "github.com/matrixorigin/matrixone/pkg/logservice"
+ "github.com/matrixorigin/matrixone/pkg/logutil"
+ logservicepb "github.com/matrixorigin/matrixone/pkg/pb/logservice"
+ "github.com/matrixorigin/matrixone/pkg/pb/metadata"
+ "github.com/matrixorigin/matrixone/pkg/pb/txn"
+ "github.com/matrixorigin/matrixone/pkg/txn/clock"
+ "github.com/matrixorigin/matrixone/pkg/txn/rpc"
+ "github.com/matrixorigin/matrixone/pkg/txn/service"
+ "github.com/matrixorigin/matrixone/pkg/txn/util"
+ "go.uber.org/multierr"
+ "go.uber.org/zap"
+)
+
+// WithLogger set logger
+func WithLogger(logger *zap.Logger) Option {
+ return func(s *store) {
+ s.logger = logger
+ }
+}
+
+// WithConfigAdjust set adjust config func
+func WithConfigAdjust(adjustConfigFunc func(c *Config)) Option {
+ return func(s *store) {
+ s.options.adjustConfigFunc = adjustConfigFunc
+ }
+}
+
+// WithRequestFilter set filtering txn.TxnRequest sent to other DNShard
+func WithRequestFilter(filter func(*txn.TxnRequest) bool) Option {
+ return func(s *store) {
+ s.options.requestFilter = filter
+ }
+}
+
+// WithMetadataFSFactory set metadata file service factory
+func WithMetadataFSFactory(factory func() fileservice.ReplaceableFileService) Option {
+ return func(s *store) {
+ s.options.metadataFSFactory = factory
+ }
+}
+
+// WithHAKeeperClientFactory set hakeeper client factory
+func WithHAKeeperClientFactory(factory func() (logservice.DNHAKeeperClient, error)) Option {
+ return func(s *store) {
+ s.options.hakeekerClientFactory = factory
+ }
+}
+
+// WithLogServiceClientFactory set log service client factory
+func WithLogServiceClientFactory(factory func(metadata.DNShard) (logservice.Client, error)) Option {
+ return func(s *store) {
+ s.options.logServiceClientFactory = factory
+ }
+}
+
+type store struct {
+ cfg *Config
+ logger *zap.Logger
+ clock clock.Clock
+ sender rpc.TxnSender
+ server rpc.TxnServer
+ hakeeperClient logservice.DNHAKeeperClient
+ metadataFS fileservice.ReplaceableFileService
+ dataFS fileservice.FileService
+ replicas *sync.Map
+ stopper *stopper.Stopper
+
+ options struct {
+ logServiceClientFactory func(metadata.DNShard) (logservice.Client, error)
+ hakeekerClientFactory func() (logservice.DNHAKeeperClient, error)
+ metadataFSFactory func() fileservice.ReplaceableFileService
+ requestFilter func(*txn.TxnRequest) bool
+ adjustConfigFunc func(c *Config)
+ }
+
+ mu struct {
+ sync.RWMutex
+ metadata metadata.DNStore
+ }
+}
+
+// NewService create DN Service
+func NewService(cfg *Config, opts ...Option) (Service, error) {
+ if err := cfg.validate(); err != nil {
+ return nil, err
+ }
+
+ s := &store{
+ cfg: cfg,
+ }
+ for _, opt := range opts {
+ opt(s)
+ }
+ s.logger = logutil.Adjust(s.logger).With(zap.String("dn-store", cfg.UUID))
+ s.replicas = &sync.Map{}
+ s.stopper = stopper.NewStopper("dn-store", stopper.WithLogger(s.logger))
+ s.mu.metadata = metadata.DNStore{UUID: cfg.UUID}
+ if s.options.adjustConfigFunc != nil {
+ s.options.adjustConfigFunc(s.cfg)
+ }
+
+ if err := s.initClocker(); err != nil {
+ return nil, err
+ }
+ if err := s.initHAKeeperClient(); err != nil {
+ return nil, err
+ }
+ if err := s.initTxnSender(); err != nil {
+ return nil, err
+ }
+ if err := s.initTxnServer(); err != nil {
+ return nil, err
+ }
+ if err := s.initFileService(); err != nil {
+ return nil, err
+ }
+ if err := s.initMetadata(); err != nil {
+ return nil, err
+ }
+ return s, nil
+}
+
+func (s *store) Start() error {
+ if err := s.startDNShards(); err != nil {
+ return err
+ }
+ if err := s.server.Start(); err != nil {
+ return err
+ }
+ return s.stopper.RunTask(s.heartbeatTask)
+}
+
+func (s *store) Close() error {
+ var err error
+ if e := s.hakeeperClient.Close(); e != nil {
+ err = multierr.Append(e, err)
+ }
+ if e := s.sender.Close(); e != nil {
+ err = multierr.Append(e, err)
+ }
+ if e := s.server.Close(); e != nil {
+ err = multierr.Append(e, err)
+ }
+ s.replicas.Range(func(_, value any) bool {
+ r := value.(*replica)
+ if e := r.close(); e != nil {
+ err = multierr.Append(e, err)
+ }
+ return true
+ })
+ s.stopper.Stop()
+ return err
+}
+
+func (s *store) StartDNReplica(shard metadata.DNShard) error {
+ return s.createReplica(shard)
+}
+
+func (s *store) CloseDNReplica(shard metadata.DNShard) error {
+ return s.removeReplica(shard.ShardID)
+}
+
+func (s *store) startDNShards() error {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+
+ for _, shard := range s.mu.metadata.Shards {
+ if err := s.createReplica(shard); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func (s *store) getDNShardInfo() []logservicepb.DNShardInfo {
+ var shards []logservicepb.DNShardInfo
+ s.replicas.Range(func(_, value any) bool {
+ r := value.(*replica)
+ shards = append(shards, logservicepb.DNShardInfo{
+ ShardID: r.shard.ShardID,
+ ReplicaID: r.shard.ReplicaID,
+ })
+ return true
+ })
+ return shards
+}
+
+func (s *store) heartbeatTask(ctx context.Context) {
+ ticker := time.NewTicker(s.cfg.HAKeeper.HeatbeatDuration.Duration)
+ defer ticker.Stop()
+
+ s.logger.Info("DNShard heartbeat started")
+ for {
+ select {
+ case <-ctx.Done():
+ s.logger.Info("DNShard heartbeat stopped")
+ return
+ case <-ticker.C:
+ ctx, cancel := context.WithTimeout(context.Background(), s.cfg.HAKeeper.HeatbeatTimeout.Duration)
+ commands, err := s.hakeeperClient.SendDNHeartbeat(ctx, logservicepb.DNStoreHeartbeat{
+ UUID: s.cfg.UUID,
+ ServiceAddress: s.cfg.ServiceAddress,
+ Shards: s.getDNShardInfo(),
+ })
+ cancel()
+
+ if err != nil {
+ s.logger.Error("send DNShard heartbeat request failed",
+ zap.Error(err))
+ continue
+ }
+
+ for _, cmd := range commands.Commands {
+ if cmd.ServiceType != logservicepb.DnService {
+ s.logger.Fatal("receive invalid schedule command",
+ zap.String("type", cmd.ServiceType.String()))
+ }
+ if cmd.ConfigChange != nil {
+ var err error
+ switch cmd.ConfigChange.ChangeType {
+ case logservicepb.AddReplica, logservicepb.StartReplica:
+ err = s.createReplica(metadata.DNShard{
+ DNShardRecord: metadata.DNShardRecord{
+ ShardID: cmd.ConfigChange.Replica.ShardID,
+ LogShardID: cmd.ConfigChange.Replica.LogShardID,
+ },
+ ReplicaID: cmd.ConfigChange.Replica.ReplicaID,
+ Address: s.cfg.ServiceAddress,
+ })
+ case logservicepb.RemoveReplica, logservicepb.StopReplica:
+ err = s.removeReplica(cmd.ConfigChange.Replica.ShardID)
+ }
+ if err != nil {
+ s.logger.Error("handle schedule command failed",
+ zap.String("command", cmd.String()),
+ zap.Error(err))
+ }
+ }
+ }
+ }
+ }
+}
+
+func (s *store) createReplica(shard metadata.DNShard) error {
+ r := newReplica(shard, s.logger.With(util.TxnDNShardField(shard)))
+ _, ok := s.replicas.LoadOrStore(shard.ShardID, r)
+ if ok {
+ return nil
+ }
+
+ storage, err := s.createTxnStorage(shard)
+ if err != nil {
+ return err
+ }
+ err = s.stopper.RunTask(func(ctx context.Context) {
+ select {
+ case <-ctx.Done():
+ return
+ default:
+ err := r.start(service.NewTxnService(r.logger,
+ shard,
+ storage,
+ s.sender,
+ s.clock,
+ s.cfg.Txn.ZombieTimeout.Duration))
+ if err != nil {
+ r.logger.Fatal("start DNShard failed",
+ zap.Error(err))
+ }
+ }
+ })
+ if err != nil {
+ return err
+ }
+
+ s.addDNShard(shard)
+ return nil
+}
+
+func (s *store) removeReplica(dnShardID uint64) error {
+ if r := s.getReplica(dnShardID); r != nil {
+ err := r.close()
+ s.replicas.Delete(dnShardID)
+ s.removeDNShard(dnShardID)
+ return err
+ }
+ return nil
+}
+
+func (s *store) getReplica(id uint64) *replica {
+ v, ok := s.replicas.Load(id)
+ if !ok {
+ return nil
+ }
+ return v.(*replica)
+}
+
+func (s *store) initTxnSender() error {
+ sender, err := rpc.NewSender(s.logger,
+ rpc.WithSenderBackendOptions(s.getBackendOptions()...),
+ rpc.WithSenderClientOptions(s.getClientOptions()...),
+ rpc.WithSenderLocalDispatch(s.dispatchLocalRequest))
+ if err != nil {
+ return err
+ }
+ s.sender = sender
+ return nil
+}
+
+func (s *store) initTxnServer() error {
+ server, err := rpc.NewTxnServer(s.cfg.ListenAddress, s.logger)
+ if err != nil {
+ return err
+ }
+ s.server = server
+ s.registerRPCHandlers()
+ return nil
+}
+
+func (s *store) initClocker() error {
+ v, err := s.createClock()
+ if err != nil {
+ return err
+ }
+ s.clock = v
+ return nil
+}
+
+func (s *store) initHAKeeperClient() error {
+ if s.options.hakeekerClientFactory != nil {
+ client, err := s.options.hakeekerClientFactory()
+ if err != nil {
+ return err
+ }
+ s.hakeeperClient = client
+ return nil
+ }
+
+ ctx, cancel := context.WithTimeout(context.Background(), s.cfg.HAKeeper.DiscoveryTimeout.Duration)
+ defer cancel()
+ client, err := logservice.NewDNHAKeeperClient(ctx, s.cfg.HAKeeper.ClientConfig)
+ if err != nil {
+ return err
+ }
+ s.hakeeperClient = client
+ return nil
+}
+
+func (s *store) initFileService() error {
+ if s.options.metadataFSFactory != nil {
+ s.metadataFS = s.options.metadataFSFactory()
+ } else {
+ fs, err := fileservice.NewLocalFS(s.cfg.getMetadataDir())
+ if err != nil {
+ return err
+ }
+ s.metadataFS = fs
+ }
+
+ fs, err := s.createFileService()
+ if err != nil {
+ return err
+ }
+ s.dataFS = fs
+ return nil
+}
+
+func (s *store) getBackendOptions() []morpc.BackendOption {
+ return []morpc.BackendOption{
+ morpc.WithBackendLogger(s.logger),
+ morpc.WithBackendFilter(func(m morpc.Message) bool {
+ return s.options.requestFilter == nil || s.options.requestFilter(m.(*txn.TxnRequest))
+ }),
+ morpc.WithBackendBusyBufferSize(s.cfg.RPC.BusyQueueSize),
+ morpc.WithBackendBufferSize(s.cfg.RPC.SendQueueSize),
+ morpc.WithBackendGoettyOptions(goetty.WithBufSize(int(s.cfg.RPC.ReadBufferSize), int(s.cfg.RPC.WriteBufferSize))),
+ }
+}
+
+func (s *store) getClientOptions() []morpc.ClientOption {
+ return []morpc.ClientOption{
+ morpc.WithClientLogger(s.logger),
+ morpc.WithClientMaxBackendPerHost(s.cfg.RPC.MaxConnections),
+ }
+}
diff --git a/pkg/dnservice/store_metadata.go b/pkg/dnservice/store_metadata.go
new file mode 100644
index 0000000000000000000000000000000000000000..c1b6e8353e7c8ae4614e7877639bce6c3ca9fe4f
--- /dev/null
+++ b/pkg/dnservice/store_metadata.go
@@ -0,0 +1,110 @@
+// Copyright 2021 - 2022 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package dnservice
+
+import (
+ "context"
+ "time"
+
+ "github.com/fagongzi/util/protoc"
+ "github.com/matrixorigin/matrixone/pkg/fileservice"
+ "github.com/matrixorigin/matrixone/pkg/pb/metadata"
+ "go.uber.org/zap"
+)
+
+const (
+ metadataFile = "metadata.data"
+)
+
+func (s *store) initMetadata() error {
+ ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+ defer cancel()
+
+ vec := &fileservice.IOVector{
+ FilePath: metadataFile,
+ Entries: []fileservice.IOEntry{
+ {
+ Offset: 0,
+ Size: -1,
+ },
+ },
+ }
+ if err := s.metadataFS.Read(ctx, vec); err != nil {
+ if err == fileservice.ErrFileNotFound {
+ return nil
+ }
+ return err
+ }
+
+ if len(vec.Entries[0].Data) == 0 {
+ return nil
+ }
+
+ v := &metadata.DNStore{}
+ protoc.MustUnmarshal(v, vec.Entries[0].Data)
+ if v.UUID != s.mu.metadata.UUID {
+ s.logger.Fatal("BUG: disk DNStore and start DNStore not match",
+ zap.String("disk-store", v.UUID))
+ }
+ s.mu.metadata = *v
+ return nil
+}
+
+func (s *store) addDNShard(shard metadata.DNShard) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+
+ for _, dn := range s.mu.metadata.Shards {
+ if dn.ShardID == shard.ShardID {
+ return
+ }
+ }
+ s.mu.metadata.Shards = append(s.mu.metadata.Shards, shard)
+ s.mustUpdateMetadataLocked()
+}
+
+func (s *store) removeDNShard(id uint64) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+
+ var newShards []metadata.DNShard
+ for _, dn := range s.mu.metadata.Shards {
+ if dn.ShardID != id {
+ newShards = append(newShards, dn)
+ }
+ }
+ s.mu.metadata.Shards = newShards
+ s.mustUpdateMetadataLocked()
+}
+
+func (s *store) mustUpdateMetadataLocked() {
+ ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+ defer cancel()
+
+ vec := fileservice.IOVector{
+ FilePath: metadataFile,
+ Entries: []fileservice.IOEntry{
+ {
+ Offset: 0,
+ Size: s.mu.metadata.Size(),
+ Data: protoc.MustMarshal(&s.mu.metadata),
+ },
+ },
+ }
+ if err := s.metadataFS.Replace(ctx, vec); err != nil {
+ s.logger.Fatal("update metadata to local file failed",
+ zap.Error(err))
+ }
+}
diff --git a/pkg/dnservice/store_metadata_test.go b/pkg/dnservice/store_metadata_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..9755424da2fb06f03c913c43637a97215e5cb11d
--- /dev/null
+++ b/pkg/dnservice/store_metadata_test.go
@@ -0,0 +1,93 @@
+// Copyright 2021 - 2022 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package dnservice
+
+import (
+ "context"
+ "testing"
+
+ "github.com/fagongzi/util/protoc"
+ "github.com/matrixorigin/matrixone/pkg/fileservice"
+ "github.com/matrixorigin/matrixone/pkg/logutil"
+ "github.com/matrixorigin/matrixone/pkg/pb/metadata"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestInitMetadata(t *testing.T) {
+ fs, err := fileservice.NewMemoryFS()
+ assert.NoError(t, err)
+
+ s := &store{logger: logutil.GetPanicLogger(), metadataFS: fs}
+ assert.NoError(t, s.initMetadata())
+}
+
+func TestInitMetadataWithExistData(t *testing.T) {
+ fs, err := fileservice.NewMemoryFS()
+ assert.NoError(t, err)
+ value := metadata.DNStore{
+ UUID: "dn1",
+ Shards: []metadata.DNShard{
+ {
+ DNShardRecord: metadata.DNShardRecord{ShardID: 1},
+ },
+ {
+ DNShardRecord: metadata.DNShardRecord{ShardID: 2},
+ },
+ },
+ }
+ assert.NoError(t, fs.Write(context.Background(), fileservice.IOVector{
+ FilePath: metadataFile,
+ Entries: []fileservice.IOEntry{
+ {
+ Offset: 0,
+ Size: value.Size(),
+ Data: protoc.MustMarshal(&value),
+ },
+ },
+ }))
+
+ s := &store{logger: logutil.GetPanicLogger(), metadataFS: fs}
+ s.mu.metadata.UUID = "dn1"
+ assert.NoError(t, s.initMetadata())
+ assert.Equal(t, value, s.mu.metadata)
+}
+
+func TestInitMetadataWithInvalidUUIDWillPanic(t *testing.T) {
+ defer func() {
+ if err := recover(); err != nil {
+ return
+ }
+ assert.Fail(t, "must panic")
+ }()
+
+ fs, err := fileservice.NewMemoryFS()
+ assert.NoError(t, err)
+ value := metadata.DNStore{
+ UUID: "dn1",
+ }
+ assert.NoError(t, fs.Write(context.Background(), fileservice.IOVector{
+ FilePath: metadataFile,
+ Entries: []fileservice.IOEntry{
+ {
+ Offset: 0,
+ Size: value.Size(),
+ Data: protoc.MustMarshal(&value),
+ },
+ },
+ }))
+
+ s := &store{logger: logutil.GetPanicLogger(), metadataFS: fs}
+ assert.NoError(t, s.initMetadata())
+}
diff --git a/pkg/dnservice/store_rpc_handler.go b/pkg/dnservice/store_rpc_handler.go
new file mode 100644
index 0000000000000000000000000000000000000000..9f05c79355127ab6adb4fb7c1eb6eca63385b9b9
--- /dev/null
+++ b/pkg/dnservice/store_rpc_handler.go
@@ -0,0 +1,139 @@
+// Copyright 2021 - 2022 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package dnservice
+
+import (
+ "context"
+
+ "github.com/matrixorigin/matrixone/pkg/pb/metadata"
+ "github.com/matrixorigin/matrixone/pkg/pb/txn"
+ "github.com/matrixorigin/matrixone/pkg/txn/rpc"
+)
+
+func (s *store) registerRPCHandlers() {
+ // request from CN node
+ s.server.RegisterMethodHandler(txn.TxnMethod_Read, s.handleRead)
+ s.server.RegisterMethodHandler(txn.TxnMethod_Write, s.handleWrite)
+ s.server.RegisterMethodHandler(txn.TxnMethod_Commit, s.handleCommit)
+ s.server.RegisterMethodHandler(txn.TxnMethod_Rollback, s.handleRollback)
+
+ // request from other DN node
+ s.server.RegisterMethodHandler(txn.TxnMethod_Prepare, s.handlePrepare)
+ s.server.RegisterMethodHandler(txn.TxnMethod_CommitDNShard, s.handleCommitDNShard)
+ s.server.RegisterMethodHandler(txn.TxnMethod_RollbackDNShard, s.handleRollbackDNShard)
+ s.server.RegisterMethodHandler(txn.TxnMethod_GetStatus, s.handleGetStatus)
+}
+
+func (s *store) dispatchLocalRequest(shard metadata.DNShard) rpc.TxnRequestHandleFunc {
+ r := s.getReplica(shard.ShardID)
+ if r == nil {
+ return nil
+ }
+ return r.handleLocalRequest
+}
+
+func (s *store) handleRead(ctx context.Context, request *txn.TxnRequest, response *txn.TxnResponse) error {
+ shard := request.GetTargetDN()
+ r := s.getReplica(shard.ShardID)
+ if r == nil {
+ return nil
+ }
+ r.waitStarted()
+ prepareResponse(request, response)
+ return r.service.Read(ctx, request, response)
+}
+
+func (s *store) handleWrite(ctx context.Context, request *txn.TxnRequest, response *txn.TxnResponse) error {
+ shard := request.GetTargetDN()
+ r := s.getReplica(shard.ShardID)
+ if r == nil {
+ return nil
+ }
+ r.waitStarted()
+ prepareResponse(request, response)
+ return r.service.Write(ctx, request, response)
+}
+
+func (s *store) handleCommit(ctx context.Context, request *txn.TxnRequest, response *txn.TxnResponse) error {
+ shard := request.GetTargetDN()
+ r := s.getReplica(shard.ShardID)
+ if r == nil {
+ return nil
+ }
+ r.waitStarted()
+ prepareResponse(request, response)
+ return r.service.Commit(ctx, request, response)
+}
+
+func (s *store) handleRollback(ctx context.Context, request *txn.TxnRequest, response *txn.TxnResponse) error {
+ shard := request.GetTargetDN()
+ r := s.getReplica(shard.ShardID)
+ if r == nil {
+ return nil
+ }
+ r.waitStarted()
+ prepareResponse(request, response)
+ return r.service.Rollback(ctx, request, response)
+}
+
+func (s *store) handlePrepare(ctx context.Context, request *txn.TxnRequest, response *txn.TxnResponse) error {
+ shard := request.GetTargetDN()
+ r := s.getReplica(shard.ShardID)
+ if r == nil {
+ return nil
+ }
+ r.waitStarted()
+ prepareResponse(request, response)
+ return r.service.Prepare(ctx, request, response)
+}
+
+func (s *store) handleCommitDNShard(ctx context.Context, request *txn.TxnRequest, response *txn.TxnResponse) error {
+ shard := request.GetTargetDN()
+ r := s.getReplica(shard.ShardID)
+ if r == nil {
+ return nil
+ }
+ r.waitStarted()
+ prepareResponse(request, response)
+ return r.service.CommitDNShard(ctx, request, response)
+}
+
+func (s *store) handleRollbackDNShard(ctx context.Context, request *txn.TxnRequest, response *txn.TxnResponse) error {
+ shard := request.GetTargetDN()
+ r := s.getReplica(shard.ShardID)
+ if r == nil {
+ return nil
+ }
+ r.waitStarted()
+ prepareResponse(request, response)
+ return r.service.RollbackDNShard(ctx, request, response)
+}
+
+func (s *store) handleGetStatus(ctx context.Context, request *txn.TxnRequest, response *txn.TxnResponse) error {
+ shard := request.GetTargetDN()
+ r := s.getReplica(shard.ShardID)
+ if r == nil {
+ return nil
+ }
+ r.waitStarted()
+ prepareResponse(request, response)
+ return r.service.GetStatus(ctx, request, response)
+}
+
+func prepareResponse(request *txn.TxnRequest, response *txn.TxnResponse) {
+ response.Method = request.Method
+ response.Flag = request.Flag
+ response.RequestID = request.RequestID
+}
diff --git a/pkg/dnservice/store_rpc_handler_test.go b/pkg/dnservice/store_rpc_handler_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..8a4d08024a02475aab560529330b3bbde88fc28b
--- /dev/null
+++ b/pkg/dnservice/store_rpc_handler_test.go
@@ -0,0 +1,133 @@
+// Copyright 2021 - 2022 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package dnservice
+
+import (
+ "context"
+ "testing"
+ "time"
+
+ "github.com/matrixorigin/matrixone/pkg/pb/txn"
+ "github.com/matrixorigin/matrixone/pkg/txn/service"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestHandleRead(t *testing.T) {
+ runDNStoreTest(t, func(s *store) {
+ shard := newTestDNShard(1, 2, 3)
+ assert.NoError(t, s.StartDNReplica(shard))
+
+ req := service.NewTestReadRequest(1, service.NewTestTxn(1, 1, 1), 1)
+ req.CNRequest.Target.ReplicaID = 2
+ assert.NoError(t, s.handleRead(context.Background(), &req, &txn.TxnResponse{}))
+ })
+}
+
+func TestHandleWrite(t *testing.T) {
+ runDNStoreTest(t, func(s *store) {
+ shard := newTestDNShard(1, 2, 3)
+ assert.NoError(t, s.StartDNReplica(shard))
+
+ req := service.NewTestWriteRequest(1, service.NewTestTxn(1, 1, 1), 1)
+ req.CNRequest.Target.ReplicaID = 2
+ assert.NoError(t, s.handleWrite(context.Background(), &req, &txn.TxnResponse{}))
+ })
+}
+
+func TestHandleCommit(t *testing.T) {
+ runDNStoreTest(t, func(s *store) {
+ shard := newTestDNShard(1, 2, 3)
+ assert.NoError(t, s.StartDNReplica(shard))
+
+ req := service.NewTestCommitRequest(service.NewTestTxn(1, 1, 1))
+ req.Txn.DNShards[0].ReplicaID = 2
+ assert.NoError(t, s.handleCommit(context.Background(), &req, &txn.TxnResponse{}))
+ })
+}
+
+func TestHandleRollback(t *testing.T) {
+ runDNStoreTest(t, func(s *store) {
+ shard := newTestDNShard(1, 2, 3)
+ assert.NoError(t, s.StartDNReplica(shard))
+
+ req := service.NewTestRollbackRequest(service.NewTestTxn(1, 1, 1))
+ req.Txn.DNShards[0].ReplicaID = 2
+ assert.NoError(t, s.handleRollback(context.Background(), &req, &txn.TxnResponse{}))
+ })
+}
+
+func TestHandlePrepare(t *testing.T) {
+ runDNStoreTest(t, func(s *store) {
+ shard := newTestDNShard(1, 2, 3)
+ assert.NoError(t, s.StartDNReplica(shard))
+
+ req := service.NewTestPrepareRequest(service.NewTestTxn(1, 1, 1), 1)
+ req.PrepareRequest.DNShard.ReplicaID = 2
+ assert.NoError(t, s.handlePrepare(context.Background(), &req, &txn.TxnResponse{}))
+
+ ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+ defer cancel()
+ _, err := s.sender.Send(ctx, []txn.TxnRequest{req})
+ assert.NoError(t, err)
+ })
+}
+
+func TestHandleGetStatus(t *testing.T) {
+ runDNStoreTest(t, func(s *store) {
+ shard := newTestDNShard(1, 2, 3)
+ assert.NoError(t, s.StartDNReplica(shard))
+
+ req := service.NewTestGetStatusRequest(service.NewTestTxn(1, 1, 1), 1)
+ req.GetStatusRequest.DNShard.ReplicaID = 2
+ assert.NoError(t, s.handleGetStatus(context.Background(), &req, &txn.TxnResponse{}))
+
+ ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+ defer cancel()
+ _, err := s.sender.Send(ctx, []txn.TxnRequest{req})
+ assert.NoError(t, err)
+ })
+}
+
+func TestHandleCommitDNShard(t *testing.T) {
+ runDNStoreTest(t, func(s *store) {
+ shard := newTestDNShard(1, 2, 3)
+ assert.NoError(t, s.StartDNReplica(shard))
+
+ req := service.NewTestCommitShardRequest(service.NewTestTxn(1, 1, 1))
+ req.CommitDNShardRequest.DNShard.ReplicaID = 2
+ assert.NoError(t, s.handleCommitDNShard(context.Background(), &req, &txn.TxnResponse{}))
+
+ ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+ defer cancel()
+ _, err := s.sender.Send(ctx, []txn.TxnRequest{req})
+ assert.NoError(t, err)
+ })
+}
+
+func TestHandleRollbackDNShard(t *testing.T) {
+ runDNStoreTest(t, func(s *store) {
+ shard := newTestDNShard(1, 2, 3)
+ assert.NoError(t, s.StartDNReplica(shard))
+
+ req := service.NewTestRollbackShardRequest(service.NewTestTxn(1, 1, 1))
+ req.RollbackDNShardRequest.DNShard.ReplicaID = 2
+ assert.NoError(t, s.handleRollbackDNShard(context.Background(), &req, &txn.TxnResponse{}))
+
+ ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+ defer cancel()
+ _, err := s.sender.Send(ctx, []txn.TxnRequest{req})
+ assert.NoError(t, err)
+ })
+}
diff --git a/pkg/dnservice/store_test.go b/pkg/dnservice/store_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..1ffec40f1d346764a67edb87d4d31e30c4072035
--- /dev/null
+++ b/pkg/dnservice/store_test.go
@@ -0,0 +1,216 @@
+// Copyright 2021 - 2022 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package dnservice
+
+import (
+ "context"
+ "math"
+ "os"
+ "sync"
+ "sync/atomic"
+ "testing"
+ "time"
+
+ "github.com/matrixorigin/matrixone/pkg/logservice"
+ logservicepb "github.com/matrixorigin/matrixone/pkg/pb/logservice"
+ "github.com/matrixorigin/matrixone/pkg/pb/metadata"
+ "github.com/matrixorigin/matrixone/pkg/txn/service"
+ "github.com/matrixorigin/matrixone/pkg/txn/storage/mem"
+ "github.com/stretchr/testify/assert"
+)
+
+var (
+ testDNStoreAddr = "unix:///tmp/test-dnstore.sock"
+ testDataDir = "/tmp/mo/dn"
+)
+
+func TestNewAndStartAndCloseService(t *testing.T) {
+ runDNStoreTest(t, func(s *store) {
+ thc := s.hakeeperClient.(*testHAKeeperClient)
+ for {
+ if v := thc.getCount(); v > 0 {
+ return
+ }
+ }
+ })
+}
+
+func TestAddReplica(t *testing.T) {
+ runDNStoreTest(t, func(s *store) {
+ thc := s.hakeeperClient.(*testHAKeeperClient)
+ thc.setCommandBatch(logservicepb.CommandBatch{
+ Commands: []logservicepb.ScheduleCommand{
+ {
+ ServiceType: logservicepb.DnService,
+ ConfigChange: &logservicepb.ConfigChange{
+ ChangeType: logservicepb.AddReplica,
+ Replica: logservicepb.Replica{
+ LogShardID: 3,
+ ReplicaID: 2,
+ ShardID: 1,
+ },
+ },
+ },
+ },
+ })
+
+ for {
+ r := s.getReplica(1)
+ if r != nil {
+ r.waitStarted()
+ assert.Equal(t, newTestDNShard(1, 2, 3), r.shard)
+ return
+ }
+ time.Sleep(time.Millisecond * 10)
+ }
+ })
+}
+
+func TestStartReplica(t *testing.T) {
+ runDNStoreTest(t, func(s *store) {
+ assert.NoError(t, s.StartDNReplica(newTestDNShard(1, 2, 3)))
+ r := s.getReplica(1)
+ r.waitStarted()
+ assert.Equal(t, newTestDNShard(1, 2, 3), r.shard)
+ })
+}
+
+func TestRemoveReplica(t *testing.T) {
+ runDNStoreTest(t, func(s *store) {
+ assert.NoError(t, s.StartDNReplica(newTestDNShard(1, 2, 3)))
+ r := s.getReplica(1)
+ r.waitStarted()
+
+ thc := s.hakeeperClient.(*testHAKeeperClient)
+ thc.setCommandBatch(logservicepb.CommandBatch{
+ Commands: []logservicepb.ScheduleCommand{
+ {
+ ServiceType: logservicepb.DnService,
+ ConfigChange: &logservicepb.ConfigChange{
+ ChangeType: logservicepb.RemoveReplica,
+ Replica: logservicepb.Replica{
+ LogShardID: 3,
+ ReplicaID: 2,
+ ShardID: 1,
+ },
+ },
+ },
+ },
+ })
+
+ for {
+ r := s.getReplica(1)
+ if r == nil {
+ return
+ }
+ time.Sleep(time.Millisecond * 10)
+ }
+ })
+}
+
+func TestCloseReplica(t *testing.T) {
+ runDNStoreTest(t, func(s *store) {
+ shard := newTestDNShard(1, 2, 3)
+ assert.NoError(t, s.StartDNReplica(shard))
+ r := s.getReplica(1)
+ r.waitStarted()
+ assert.Equal(t, shard, r.shard)
+
+ assert.NoError(t, s.CloseDNReplica(shard))
+ assert.Nil(t, s.getReplica(1))
+ })
+}
+
+func runDNStoreTest(t *testing.T, testFn func(*store), opts ...Option) {
+ thc := newTestHAKeeperClient()
+
+ opts = append(opts, WithHAKeeperClientFactory(func() (logservice.DNHAKeeperClient, error) {
+ return thc, nil
+ }),
+ WithLogServiceClientFactory(func(d metadata.DNShard) (logservice.Client, error) {
+ return mem.NewMemLog(), nil
+ }),
+ WithConfigAdjust(func(c *Config) {
+ c.HAKeeper.HeatbeatDuration.Duration = time.Millisecond * 10
+ c.Txn.Storage.Backend = memStorageBackend
+ }))
+
+ s := newTestStore(t, "u1", opts...)
+ defer func() {
+ assert.NoError(t, s.Close())
+ }()
+
+ assert.NoError(t, s.Start())
+ testFn(s)
+}
+
+func newTestStore(t *testing.T, uuid string, options ...Option) *store {
+ assert.NoError(t, os.RemoveAll(testDataDir))
+ assert.NoError(t, os.RemoveAll(testDNStoreAddr[7:]))
+ assert.NoError(t, os.MkdirAll(testDataDir, 0755))
+ c := &Config{
+ UUID: uuid,
+ DataDir: testDataDir,
+ ListenAddress: testDNStoreAddr,
+ }
+ c.Txn.Clock.MaxClockOffset.Duration = time.Duration(math.MaxInt64)
+ s, err := NewService(c, options...)
+ assert.NoError(t, err)
+ return s.(*store)
+}
+
+func newTestDNShard(shardID, replicaID, logShardID uint64) metadata.DNShard {
+ dnShard := service.NewTestDNShard(shardID)
+ dnShard.ReplicaID = replicaID
+ dnShard.LogShardID = logShardID
+ dnShard.Address = testDNStoreAddr
+ return dnShard
+}
+
+type testHAKeeperClient struct {
+ mu struct {
+ sync.RWMutex
+ commandBatch logservicepb.CommandBatch
+ }
+
+ atomic struct {
+ count uint64
+ }
+}
+
+func newTestHAKeeperClient() *testHAKeeperClient {
+ return &testHAKeeperClient{}
+}
+
+func (thc *testHAKeeperClient) setCommandBatch(commandBatch logservicepb.CommandBatch) {
+ thc.mu.Lock()
+ defer thc.mu.Unlock()
+ thc.mu.commandBatch = commandBatch
+}
+
+func (thc *testHAKeeperClient) getCount() uint64 {
+ return atomic.LoadUint64(&thc.atomic.count)
+}
+
+func (thc *testHAKeeperClient) Close() error {
+ return nil
+}
+
+func (thc *testHAKeeperClient) SendDNHeartbeat(ctx context.Context, hb logservicepb.DNStoreHeartbeat) (logservicepb.CommandBatch, error) {
+ atomic.AddUint64(&thc.atomic.count, 1)
+ thc.mu.RLock()
+ defer thc.mu.RUnlock()
+ return thc.mu.commandBatch, nil
+}
diff --git a/pkg/dnservice/types.go b/pkg/dnservice/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..6b7bbc2298096a51c353eac5eff98fc5f1f64f02
--- /dev/null
+++ b/pkg/dnservice/types.go
@@ -0,0 +1,36 @@
+// Copyright 2021 - 2022 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package dnservice
+
+import (
+ "github.com/matrixorigin/matrixone/pkg/pb/metadata"
+)
+
+// Option store option
+type Option func(*store)
+
+// Service DN Service
+type Service interface {
+ // Start start dn store. Start all DNShards currently managed by the Store and listen
+ // to and process requests from CN and other DNs.
+ Start() error
+ // Close close dn store
+ Close() error
+
+ // StartDNReplica start the DNShard replica
+ StartDNReplica(metadata.DNShard) error
+ // CloseDNReplica close the DNShard replica.
+ CloseDNReplica(shard metadata.DNShard) error
+}
diff --git a/pkg/pb/logservice/logservice.pb.go b/pkg/pb/logservice/logservice.pb.go
index a0a022f55a44041b9e8687e36e3b9b606703cd57..f96e7e653243168479aa9884f6672ff6960b9036 100644
--- a/pkg/pb/logservice/logservice.pb.go
+++ b/pkg/pb/logservice/logservice.pb.go
@@ -23,7 +23,7 @@ var _ = math.Inf
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
type UpdateType int32
@@ -364,7 +364,7 @@ func (m *CNNode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CNNode.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -427,7 +427,7 @@ func (m *DNNode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DNNode.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -501,7 +501,7 @@ func (m *LogShardInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_LogShardInfo.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -579,7 +579,7 @@ func (m *LogReplicaInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro
return xxx_messageInfo_LogReplicaInfo.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -628,7 +628,7 @@ func (m *CNStoreHeartbeat) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
return xxx_messageInfo_CNStoreHeartbeat.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -692,7 +692,7 @@ func (m *LogStoreHeartbeat) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
return xxx_messageInfo_LogStoreHeartbeat.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -774,7 +774,7 @@ func (m *DNShardInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_DNShardInfo.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -834,7 +834,7 @@ func (m *DNStoreHeartbeat) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
return xxx_messageInfo_DNStoreHeartbeat.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -899,7 +899,7 @@ func (m *RSMState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_RSMState.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -977,7 +977,7 @@ func (m *LogRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_LogRecord.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1043,7 +1043,7 @@ func (m *LogRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_LogRequest.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1125,7 +1125,7 @@ func (m *TsoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_TsoRequest.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1179,7 +1179,7 @@ func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Request.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1277,7 +1277,7 @@ func (m *LogResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_LogResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1346,7 +1346,7 @@ func (m *Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Response.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1449,7 +1449,7 @@ func (m *LogRecordResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
return xxx_messageInfo_LogRecordResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1496,7 +1496,7 @@ func (m *TsoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_TsoResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1550,7 +1550,7 @@ func (m *Replica) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Replica.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1629,7 +1629,7 @@ func (m *ConfigChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_ConfigChange.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1691,7 +1691,7 @@ func (m *ShutdownStore) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
return xxx_messageInfo_ShutdownStore.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1744,7 +1744,7 @@ func (m *ScheduleCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, err
return xxx_messageInfo_ScheduleCommand.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1820,7 +1820,7 @@ func (m *CommandBatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_CommandBatch.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1876,7 +1876,7 @@ func (m *CNStoreInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_CNStoreInfo.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1932,7 +1932,7 @@ func (m *CNState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CNState.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1982,7 +1982,7 @@ func (m *DNStoreInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_DNStoreInfo.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -2045,7 +2045,7 @@ func (m *DNState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DNState.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -2093,7 +2093,7 @@ func (m *ClusterDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro
return xxx_messageInfo_ClusterDetails.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -2151,7 +2151,7 @@ func (m *ClusterInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_ClusterInfo.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -2207,7 +2207,7 @@ func (m *InitialClusterRequest) XXX_Marshal(b []byte, deterministic bool) ([]byt
return xxx_messageInfo_InitialClusterRequest.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -2273,7 +2273,7 @@ func (m *LogStoreInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_LogStoreInfo.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -2356,7 +2356,7 @@ func (m *LogState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_LogState.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -2416,7 +2416,7 @@ func (m *CheckerState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_CheckerState.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -2501,7 +2501,7 @@ func (m *HAKeeperRSMState) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
return xxx_messageInfo_HAKeeperRSMState.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -2799,7 +2799,7 @@ var fileDescriptor_fd1040c5381ab5a7 = []byte{
func (m *CNNode) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -2807,37 +2807,45 @@ func (m *CNNode) Marshal() (dAtA []byte, err error) {
}
func (m *CNNode) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CNNode) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.UUID) > 0 {
- dAtA[i] = 0xa
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(len(m.UUID)))
- i += copy(dAtA[i:], m.UUID)
- }
- if len(m.ServiceAddress) > 0 {
- dAtA[i] = 0x12
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(len(m.ServiceAddress)))
- i += copy(dAtA[i:], m.ServiceAddress)
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if m.Tick != 0 {
- dAtA[i] = 0x18
- i++
i = encodeVarintLogservice(dAtA, i, uint64(m.Tick))
+ i--
+ dAtA[i] = 0x18
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.ServiceAddress) > 0 {
+ i -= len(m.ServiceAddress)
+ copy(dAtA[i:], m.ServiceAddress)
+ i = encodeVarintLogservice(dAtA, i, uint64(len(m.ServiceAddress)))
+ i--
+ dAtA[i] = 0x12
}
- return i, nil
+ if len(m.UUID) > 0 {
+ i -= len(m.UUID)
+ copy(dAtA[i:], m.UUID)
+ i = encodeVarintLogservice(dAtA, i, uint64(len(m.UUID)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
}
func (m *DNNode) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -2845,37 +2853,45 @@ func (m *DNNode) Marshal() (dAtA []byte, err error) {
}
func (m *DNNode) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DNNode) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.UUID) > 0 {
- dAtA[i] = 0xa
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(len(m.UUID)))
- i += copy(dAtA[i:], m.UUID)
- }
- if len(m.ServiceAddress) > 0 {
- dAtA[i] = 0x12
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(len(m.ServiceAddress)))
- i += copy(dAtA[i:], m.ServiceAddress)
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if m.Tick != 0 {
- dAtA[i] = 0x18
- i++
i = encodeVarintLogservice(dAtA, i, uint64(m.Tick))
+ i--
+ dAtA[i] = 0x18
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.ServiceAddress) > 0 {
+ i -= len(m.ServiceAddress)
+ copy(dAtA[i:], m.ServiceAddress)
+ i = encodeVarintLogservice(dAtA, i, uint64(len(m.ServiceAddress)))
+ i--
+ dAtA[i] = 0x12
}
- return i, nil
+ if len(m.UUID) > 0 {
+ i -= len(m.UUID)
+ copy(dAtA[i:], m.UUID)
+ i = encodeVarintLogservice(dAtA, i, uint64(len(m.UUID)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
}
func (m *LogShardInfo) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -2883,56 +2899,63 @@ func (m *LogShardInfo) Marshal() (dAtA []byte, err error) {
}
func (m *LogShardInfo) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *LogShardInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.ShardID != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.ShardID))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
+ if m.Term != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.Term))
+ i--
+ dAtA[i] = 0x28
+ }
+ if m.LeaderID != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.LeaderID))
+ i--
+ dAtA[i] = 0x20
+ }
+ if m.Epoch != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.Epoch))
+ i--
+ dAtA[i] = 0x18
}
if len(m.Replicas) > 0 {
for k := range m.Replicas {
- dAtA[i] = 0x12
- i++
v := m.Replicas[k]
- mapSize := 1 + sovLogservice(uint64(k)) + 1 + len(v) + sovLogservice(uint64(len(v)))
- i = encodeVarintLogservice(dAtA, i, uint64(mapSize))
- dAtA[i] = 0x8
- i++
+ baseI := i
+ i -= len(v)
+ copy(dAtA[i:], v)
+ i = encodeVarintLogservice(dAtA, i, uint64(len(v)))
+ i--
+ dAtA[i] = 0x12
i = encodeVarintLogservice(dAtA, i, uint64(k))
+ i--
+ dAtA[i] = 0x8
+ i = encodeVarintLogservice(dAtA, i, uint64(baseI-i))
+ i--
dAtA[i] = 0x12
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(len(v)))
- i += copy(dAtA[i:], v)
}
}
- if m.Epoch != 0 {
- dAtA[i] = 0x18
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.Epoch))
- }
- if m.LeaderID != 0 {
- dAtA[i] = 0x20
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.LeaderID))
- }
- if m.Term != 0 {
- dAtA[i] = 0x28
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.Term))
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.ShardID != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.ShardID))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *LogReplicaInfo) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -2940,33 +2963,41 @@ func (m *LogReplicaInfo) Marshal() (dAtA []byte, err error) {
}
func (m *LogReplicaInfo) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *LogReplicaInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- dAtA[i] = 0xa
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.LogShardInfo.Size()))
- n1, err1 := m.LogShardInfo.MarshalTo(dAtA[i:])
- if err1 != nil {
- return 0, err1
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- i += n1
if m.ReplicaID != 0 {
- dAtA[i] = 0x10
- i++
i = encodeVarintLogservice(dAtA, i, uint64(m.ReplicaID))
+ i--
+ dAtA[i] = 0x10
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ {
+ size, err := m.LogShardInfo.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- return i, nil
+ i--
+ dAtA[i] = 0xa
+ return len(dAtA) - i, nil
}
func (m *CNStoreHeartbeat) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -2974,32 +3005,40 @@ func (m *CNStoreHeartbeat) Marshal() (dAtA []byte, err error) {
}
func (m *CNStoreHeartbeat) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CNStoreHeartbeat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.UUID) > 0 {
- dAtA[i] = 0xa
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(len(m.UUID)))
- i += copy(dAtA[i:], m.UUID)
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.ServiceAddress) > 0 {
- dAtA[i] = 0x12
- i++
+ i -= len(m.ServiceAddress)
+ copy(dAtA[i:], m.ServiceAddress)
i = encodeVarintLogservice(dAtA, i, uint64(len(m.ServiceAddress)))
- i += copy(dAtA[i:], m.ServiceAddress)
+ i--
+ dAtA[i] = 0x12
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.UUID) > 0 {
+ i -= len(m.UUID)
+ copy(dAtA[i:], m.UUID)
+ i = encodeVarintLogservice(dAtA, i, uint64(len(m.UUID)))
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *LogStoreHeartbeat) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -3007,56 +3046,68 @@ func (m *LogStoreHeartbeat) Marshal() (dAtA []byte, err error) {
}
func (m *LogStoreHeartbeat) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *LogStoreHeartbeat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.UUID) > 0 {
- dAtA[i] = 0xa
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(len(m.UUID)))
- i += copy(dAtA[i:], m.UUID)
- }
- if len(m.RaftAddress) > 0 {
- dAtA[i] = 0x12
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(len(m.RaftAddress)))
- i += copy(dAtA[i:], m.RaftAddress)
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if len(m.ServiceAddress) > 0 {
- dAtA[i] = 0x1a
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(len(m.ServiceAddress)))
- i += copy(dAtA[i:], m.ServiceAddress)
+ if len(m.Replicas) > 0 {
+ for iNdEx := len(m.Replicas) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Replicas[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x2a
+ }
}
if len(m.GossipAddress) > 0 {
- dAtA[i] = 0x22
- i++
+ i -= len(m.GossipAddress)
+ copy(dAtA[i:], m.GossipAddress)
i = encodeVarintLogservice(dAtA, i, uint64(len(m.GossipAddress)))
- i += copy(dAtA[i:], m.GossipAddress)
+ i--
+ dAtA[i] = 0x22
}
- if len(m.Replicas) > 0 {
- for _, msg := range m.Replicas {
- dAtA[i] = 0x2a
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(msg.Size()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
- }
- i += n
- }
+ if len(m.ServiceAddress) > 0 {
+ i -= len(m.ServiceAddress)
+ copy(dAtA[i:], m.ServiceAddress)
+ i = encodeVarintLogservice(dAtA, i, uint64(len(m.ServiceAddress)))
+ i--
+ dAtA[i] = 0x1a
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.RaftAddress) > 0 {
+ i -= len(m.RaftAddress)
+ copy(dAtA[i:], m.RaftAddress)
+ i = encodeVarintLogservice(dAtA, i, uint64(len(m.RaftAddress)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(m.UUID) > 0 {
+ i -= len(m.UUID)
+ copy(dAtA[i:], m.UUID)
+ i = encodeVarintLogservice(dAtA, i, uint64(len(m.UUID)))
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DNShardInfo) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -3064,30 +3115,36 @@ func (m *DNShardInfo) Marshal() (dAtA []byte, err error) {
}
func (m *DNShardInfo) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DNShardInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.ShardID != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.ShardID))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if m.ReplicaID != 0 {
- dAtA[i] = 0x10
- i++
i = encodeVarintLogservice(dAtA, i, uint64(m.ReplicaID))
+ i--
+ dAtA[i] = 0x10
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.ShardID != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.ShardID))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DNStoreHeartbeat) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -3095,44 +3152,54 @@ func (m *DNStoreHeartbeat) Marshal() (dAtA []byte, err error) {
}
func (m *DNStoreHeartbeat) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DNStoreHeartbeat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.UUID) > 0 {
- dAtA[i] = 0xa
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(len(m.UUID)))
- i += copy(dAtA[i:], m.UUID)
- }
- if len(m.ServiceAddress) > 0 {
- dAtA[i] = 0x12
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(len(m.ServiceAddress)))
- i += copy(dAtA[i:], m.ServiceAddress)
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Shards) > 0 {
- for _, msg := range m.Shards {
- dAtA[i] = 0x1a
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(msg.Size()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
+ for iNdEx := len(m.Shards) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Shards[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- i += n
+ i--
+ dAtA[i] = 0x1a
}
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.ServiceAddress) > 0 {
+ i -= len(m.ServiceAddress)
+ copy(dAtA[i:], m.ServiceAddress)
+ i = encodeVarintLogservice(dAtA, i, uint64(len(m.ServiceAddress)))
+ i--
+ dAtA[i] = 0x12
}
- return i, nil
+ if len(m.UUID) > 0 {
+ i -= len(m.UUID)
+ copy(dAtA[i:], m.UUID)
+ i = encodeVarintLogservice(dAtA, i, uint64(len(m.UUID)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
}
func (m *RSMState) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -3140,55 +3207,61 @@ func (m *RSMState) Marshal() (dAtA []byte, err error) {
}
func (m *RSMState) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *RSMState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.Tso != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.Tso))
- }
- if m.Index != 0 {
- dAtA[i] = 0x10
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.Index))
- }
- if m.LeaseHolderID != 0 {
- dAtA[i] = 0x18
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.LeaseHolderID))
- }
- if m.TruncatedLsn != 0 {
- dAtA[i] = 0x20
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.TruncatedLsn))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.LeaseHistory) > 0 {
for k := range m.LeaseHistory {
- dAtA[i] = 0x2a
- i++
v := m.LeaseHistory[k]
- mapSize := 1 + sovLogservice(uint64(k)) + 1 + sovLogservice(uint64(v))
- i = encodeVarintLogservice(dAtA, i, uint64(mapSize))
- dAtA[i] = 0x8
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(k))
- dAtA[i] = 0x10
- i++
+ baseI := i
i = encodeVarintLogservice(dAtA, i, uint64(v))
+ i--
+ dAtA[i] = 0x10
+ i = encodeVarintLogservice(dAtA, i, uint64(k))
+ i--
+ dAtA[i] = 0x8
+ i = encodeVarintLogservice(dAtA, i, uint64(baseI-i))
+ i--
+ dAtA[i] = 0x2a
}
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.TruncatedLsn != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.TruncatedLsn))
+ i--
+ dAtA[i] = 0x20
}
- return i, nil
+ if m.LeaseHolderID != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.LeaseHolderID))
+ i--
+ dAtA[i] = 0x18
+ }
+ if m.Index != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.Index))
+ i--
+ dAtA[i] = 0x10
+ }
+ if m.Tso != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.Tso))
+ i--
+ dAtA[i] = 0x8
+ }
+ return len(dAtA) - i, nil
}
func (m *LogRecord) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -3196,36 +3269,43 @@ func (m *LogRecord) Marshal() (dAtA []byte, err error) {
}
func (m *LogRecord) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *LogRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.Lsn != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.Lsn))
- }
- if m.Type != 0 {
- dAtA[i] = 0x10
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.Type))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Data) > 0 {
- dAtA[i] = 0x1a
- i++
+ i -= len(m.Data)
+ copy(dAtA[i:], m.Data)
i = encodeVarintLogservice(dAtA, i, uint64(len(m.Data)))
- i += copy(dAtA[i:], m.Data)
+ i--
+ dAtA[i] = 0x1a
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.Type != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.Type))
+ i--
+ dAtA[i] = 0x10
}
- return i, nil
+ if m.Lsn != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.Lsn))
+ i--
+ dAtA[i] = 0x8
+ }
+ return len(dAtA) - i, nil
}
func (m *LogRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -3233,51 +3313,58 @@ func (m *LogRequest) Marshal() (dAtA []byte, err error) {
}
func (m *LogRequest) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *LogRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.Name) > 0 {
- dAtA[i] = 0xa
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(len(m.Name)))
- i += copy(dAtA[i:], m.Name)
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if m.ShardID != 0 {
- dAtA[i] = 0x10
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.ShardID))
+ if m.DNID != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.DNID))
+ i--
+ dAtA[i] = 0x30
}
- if m.Lsn != 0 {
- dAtA[i] = 0x18
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.Lsn))
+ if m.DNShardID != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.DNShardID))
+ i--
+ dAtA[i] = 0x28
}
if m.MaxSize != 0 {
- dAtA[i] = 0x20
- i++
i = encodeVarintLogservice(dAtA, i, uint64(m.MaxSize))
+ i--
+ dAtA[i] = 0x20
}
- if m.DNShardID != 0 {
- dAtA[i] = 0x28
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.DNShardID))
+ if m.Lsn != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.Lsn))
+ i--
+ dAtA[i] = 0x18
}
- if m.DNID != 0 {
- dAtA[i] = 0x30
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.DNID))
+ if m.ShardID != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.ShardID))
+ i--
+ dAtA[i] = 0x10
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.Name) > 0 {
+ i -= len(m.Name)
+ copy(dAtA[i:], m.Name)
+ i = encodeVarintLogservice(dAtA, i, uint64(len(m.Name)))
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TsoRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -3285,25 +3372,31 @@ func (m *TsoRequest) Marshal() (dAtA []byte, err error) {
}
func (m *TsoRequest) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TsoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if m.Count != 0 {
- dAtA[i] = 0x8
- i++
i = encodeVarintLogservice(dAtA, i, uint64(m.Count))
+ i--
+ dAtA[i] = 0x8
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
- }
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Request) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -3311,75 +3404,91 @@ func (m *Request) Marshal() (dAtA []byte, err error) {
}
func (m *Request) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.RequestID != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.RequestID))
- }
- if m.Method != 0 {
- dAtA[i] = 0x10
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.Method))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if m.Timeout != 0 {
- dAtA[i] = 0x18
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.Timeout))
+ {
+ size, err := m.TsoRequest.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- dAtA[i] = 0x22
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.LogRequest.Size()))
- n2, err2 := m.LogRequest.MarshalTo(dAtA[i:])
- if err2 != nil {
- return 0, err2
+ i--
+ dAtA[i] = 0x42
+ {
+ size, err := m.DNHeartbeat.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- i += n2
- dAtA[i] = 0x2a
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.LogHeartbeat.Size()))
- n3, err3 := m.LogHeartbeat.MarshalTo(dAtA[i:])
- if err3 != nil {
- return 0, err3
+ i--
+ dAtA[i] = 0x3a
+ {
+ size, err := m.CNHeartbeat.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- i += n3
+ i--
dAtA[i] = 0x32
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.CNHeartbeat.Size()))
- n4, err4 := m.CNHeartbeat.MarshalTo(dAtA[i:])
- if err4 != nil {
- return 0, err4
+ {
+ size, err := m.LogHeartbeat.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- i += n4
- dAtA[i] = 0x3a
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.DNHeartbeat.Size()))
- n5, err5 := m.DNHeartbeat.MarshalTo(dAtA[i:])
- if err5 != nil {
- return 0, err5
+ i--
+ dAtA[i] = 0x2a
+ {
+ size, err := m.LogRequest.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- i += n5
- dAtA[i] = 0x42
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.TsoRequest.Size()))
- n6, err6 := m.TsoRequest.MarshalTo(dAtA[i:])
- if err6 != nil {
- return 0, err6
+ i--
+ dAtA[i] = 0x22
+ if m.Timeout != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.Timeout))
+ i--
+ dAtA[i] = 0x18
}
- i += n6
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.Method != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.Method))
+ i--
+ dAtA[i] = 0x10
}
- return i, nil
+ if m.RequestID != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.RequestID))
+ i--
+ dAtA[i] = 0x8
+ }
+ return len(dAtA) - i, nil
}
func (m *LogResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -3387,35 +3496,41 @@ func (m *LogResponse) Marshal() (dAtA []byte, err error) {
}
func (m *LogResponse) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *LogResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.ShardID != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.ShardID))
- }
- if m.Lsn != 0 {
- dAtA[i] = 0x10
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.Lsn))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if m.LastLsn != 0 {
- dAtA[i] = 0x18
- i++
i = encodeVarintLogservice(dAtA, i, uint64(m.LastLsn))
+ i--
+ dAtA[i] = 0x18
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.Lsn != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.Lsn))
+ i--
+ dAtA[i] = 0x10
}
- return i, nil
+ if m.ShardID != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.ShardID))
+ i--
+ dAtA[i] = 0x8
+ }
+ return len(dAtA) - i, nil
}
func (m *Response) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -3423,83 +3538,98 @@ func (m *Response) Marshal() (dAtA []byte, err error) {
}
func (m *Response) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Response) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.RequestID != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.RequestID))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if m.Method != 0 {
- dAtA[i] = 0x10
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.Method))
+ {
+ size, err := m.ClusterDetails.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- if m.ErrorCode != 0 {
- dAtA[i] = 0x18
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.ErrorCode))
+ i--
+ dAtA[i] = 0x4a
+ {
+ size, err := m.TsoResponse.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- if len(m.ErrorMessage) > 0 {
- dAtA[i] = 0x22
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(len(m.ErrorMessage)))
- i += copy(dAtA[i:], m.ErrorMessage)
+ i--
+ dAtA[i] = 0x42
+ {
+ size, err := m.CommandBatch.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
+ i--
+ dAtA[i] = 0x3a
+ {
+ size, err := m.LogResponse.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x32
if m.IsHAKeeper {
- dAtA[i] = 0x28
- i++
+ i--
if m.IsHAKeeper {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
- i++
- }
- dAtA[i] = 0x32
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.LogResponse.Size()))
- n7, err7 := m.LogResponse.MarshalTo(dAtA[i:])
- if err7 != nil {
- return 0, err7
+ i--
+ dAtA[i] = 0x28
}
- i += n7
- dAtA[i] = 0x3a
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.CommandBatch.Size()))
- n8, err8 := m.CommandBatch.MarshalTo(dAtA[i:])
- if err8 != nil {
- return 0, err8
+ if len(m.ErrorMessage) > 0 {
+ i -= len(m.ErrorMessage)
+ copy(dAtA[i:], m.ErrorMessage)
+ i = encodeVarintLogservice(dAtA, i, uint64(len(m.ErrorMessage)))
+ i--
+ dAtA[i] = 0x22
}
- i += n8
- dAtA[i] = 0x42
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.TsoResponse.Size()))
- n9, err9 := m.TsoResponse.MarshalTo(dAtA[i:])
- if err9 != nil {
- return 0, err9
+ if m.ErrorCode != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.ErrorCode))
+ i--
+ dAtA[i] = 0x18
}
- i += n9
- dAtA[i] = 0x4a
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.ClusterDetails.Size()))
- n10, err10 := m.ClusterDetails.MarshalTo(dAtA[i:])
- if err10 != nil {
- return 0, err10
+ if m.Method != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.Method))
+ i--
+ dAtA[i] = 0x10
}
- i += n10
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.RequestID != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.RequestID))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *LogRecordResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -3507,32 +3637,40 @@ func (m *LogRecordResponse) Marshal() (dAtA []byte, err error) {
}
func (m *LogRecordResponse) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *LogRecordResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if len(m.Records) > 0 {
- for _, msg := range m.Records {
- dAtA[i] = 0xa
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(msg.Size()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
+ for iNdEx := len(m.Records) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Records[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- i += n
+ i--
+ dAtA[i] = 0xa
}
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
- }
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TsoResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -3540,25 +3678,31 @@ func (m *TsoResponse) Marshal() (dAtA []byte, err error) {
}
func (m *TsoResponse) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TsoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if m.Value != 0 {
- dAtA[i] = 0x8
- i++
i = encodeVarintLogservice(dAtA, i, uint64(m.Value))
+ i--
+ dAtA[i] = 0x8
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
- }
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Replica) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -3566,46 +3710,53 @@ func (m *Replica) Marshal() (dAtA []byte, err error) {
}
func (m *Replica) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Replica) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.UUID) > 0 {
- dAtA[i] = 0xa
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(len(m.UUID)))
- i += copy(dAtA[i:], m.UUID)
- }
- if m.ShardID != 0 {
- dAtA[i] = 0x10
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.ShardID))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if m.ReplicaID != 0 {
- dAtA[i] = 0x18
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.ReplicaID))
+ if m.LogShardID != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.LogShardID))
+ i--
+ dAtA[i] = 0x28
}
if m.Epoch != 0 {
- dAtA[i] = 0x20
- i++
i = encodeVarintLogservice(dAtA, i, uint64(m.Epoch))
+ i--
+ dAtA[i] = 0x20
}
- if m.LogShardID != 0 {
- dAtA[i] = 0x28
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.LogShardID))
+ if m.ReplicaID != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.ReplicaID))
+ i--
+ dAtA[i] = 0x18
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.ShardID != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.ShardID))
+ i--
+ dAtA[i] = 0x10
+ }
+ if len(m.UUID) > 0 {
+ i -= len(m.UUID)
+ copy(dAtA[i:], m.UUID)
+ i = encodeVarintLogservice(dAtA, i, uint64(len(m.UUID)))
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *ConfigChange) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -3613,49 +3764,58 @@ func (m *ConfigChange) Marshal() (dAtA []byte, err error) {
}
func (m *ConfigChange) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ConfigChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- dAtA[i] = 0xa
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.Replica.Size()))
- n11, err11 := m.Replica.MarshalTo(dAtA[i:])
- if err11 != nil {
- return 0, err11
- }
- i += n11
- if m.ChangeType != 0 {
- dAtA[i] = 0x10
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.ChangeType))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.InitialMembers) > 0 {
for k := range m.InitialMembers {
- dAtA[i] = 0x1a
- i++
v := m.InitialMembers[k]
- mapSize := 1 + sovLogservice(uint64(k)) + 1 + len(v) + sovLogservice(uint64(len(v)))
- i = encodeVarintLogservice(dAtA, i, uint64(mapSize))
- dAtA[i] = 0x8
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(k))
- dAtA[i] = 0x12
- i++
+ baseI := i
+ i -= len(v)
+ copy(dAtA[i:], v)
i = encodeVarintLogservice(dAtA, i, uint64(len(v)))
- i += copy(dAtA[i:], v)
+ i--
+ dAtA[i] = 0x12
+ i = encodeVarintLogservice(dAtA, i, uint64(k))
+ i--
+ dAtA[i] = 0x8
+ i = encodeVarintLogservice(dAtA, i, uint64(baseI-i))
+ i--
+ dAtA[i] = 0x1a
}
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.ChangeType != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.ChangeType))
+ i--
+ dAtA[i] = 0x10
+ }
+ {
+ size, err := m.Replica.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- return i, nil
+ i--
+ dAtA[i] = 0xa
+ return len(dAtA) - i, nil
}
func (m *ShutdownStore) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -3663,26 +3823,33 @@ func (m *ShutdownStore) Marshal() (dAtA []byte, err error) {
}
func (m *ShutdownStore) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ShutdownStore) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if len(m.StoreID) > 0 {
- dAtA[i] = 0xa
- i++
+ i -= len(m.StoreID)
+ copy(dAtA[i:], m.StoreID)
i = encodeVarintLogservice(dAtA, i, uint64(len(m.StoreID)))
- i += copy(dAtA[i:], m.StoreID)
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *ScheduleCommand) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -3690,61 +3857,72 @@ func (m *ScheduleCommand) Marshal() (dAtA []byte, err error) {
}
func (m *ScheduleCommand) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ScheduleCommand) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.UUID) > 0 {
- dAtA[i] = 0xa
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(len(m.UUID)))
- i += copy(dAtA[i:], m.UUID)
- }
- if m.Bootstrapping {
- dAtA[i] = 0x10
- i++
- if m.Bootstrapping {
- dAtA[i] = 1
- } else {
- dAtA[i] = 0
- }
- i++
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if m.ConfigChange != nil {
- dAtA[i] = 0x1a
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.ConfigChange.Size()))
- n12, err12 := m.ConfigChange.MarshalTo(dAtA[i:])
- if err12 != nil {
- return 0, err12
+ if m.ShutdownStore != nil {
+ {
+ size, err := m.ShutdownStore.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- i += n12
+ i--
+ dAtA[i] = 0x2a
}
if m.ServiceType != 0 {
- dAtA[i] = 0x20
- i++
i = encodeVarintLogservice(dAtA, i, uint64(m.ServiceType))
+ i--
+ dAtA[i] = 0x20
}
- if m.ShutdownStore != nil {
- dAtA[i] = 0x2a
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.ShutdownStore.Size()))
- n13, err13 := m.ShutdownStore.MarshalTo(dAtA[i:])
- if err13 != nil {
- return 0, err13
+ if m.ConfigChange != nil {
+ {
+ size, err := m.ConfigChange.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- i += n13
+ i--
+ dAtA[i] = 0x1a
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.Bootstrapping {
+ i--
+ if m.Bootstrapping {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ i--
+ dAtA[i] = 0x10
+ }
+ if len(m.UUID) > 0 {
+ i -= len(m.UUID)
+ copy(dAtA[i:], m.UUID)
+ i = encodeVarintLogservice(dAtA, i, uint64(len(m.UUID)))
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *CommandBatch) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -3752,37 +3930,45 @@ func (m *CommandBatch) Marshal() (dAtA []byte, err error) {
}
func (m *CommandBatch) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CommandBatch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.Term != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.Term))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Commands) > 0 {
- for _, msg := range m.Commands {
- dAtA[i] = 0x12
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(msg.Size()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
+ for iNdEx := len(m.Commands) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Commands[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- i += n
+ i--
+ dAtA[i] = 0x12
}
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.Term != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.Term))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *CNStoreInfo) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -3790,31 +3976,38 @@ func (m *CNStoreInfo) Marshal() (dAtA []byte, err error) {
}
func (m *CNStoreInfo) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CNStoreInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.Tick != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.Tick))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.ServiceAddress) > 0 {
- dAtA[i] = 0x12
- i++
+ i -= len(m.ServiceAddress)
+ copy(dAtA[i:], m.ServiceAddress)
i = encodeVarintLogservice(dAtA, i, uint64(len(m.ServiceAddress)))
- i += copy(dAtA[i:], m.ServiceAddress)
+ i--
+ dAtA[i] = 0x12
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.Tick != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.Tick))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *CNState) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -3822,46 +4015,50 @@ func (m *CNState) Marshal() (dAtA []byte, err error) {
}
func (m *CNState) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CNState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if len(m.Stores) > 0 {
for k := range m.Stores {
- dAtA[i] = 0xa
- i++
v := m.Stores[k]
- msgSize := 0
- if (&v) != nil {
- msgSize = (&v).Size()
- msgSize += 1 + sovLogservice(uint64(msgSize))
+ baseI := i
+ {
+ size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- mapSize := 1 + len(k) + sovLogservice(uint64(len(k))) + msgSize
- i = encodeVarintLogservice(dAtA, i, uint64(mapSize))
- dAtA[i] = 0xa
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(len(k)))
- i += copy(dAtA[i:], k)
+ i--
dAtA[i] = 0x12
- i++
- i = encodeVarintLogservice(dAtA, i, uint64((&v).Size()))
- n14, err14 := (&v).MarshalTo(dAtA[i:])
- if err14 != nil {
- return 0, err14
- }
- i += n14
+ i -= len(k)
+ copy(dAtA[i:], k)
+ i = encodeVarintLogservice(dAtA, i, uint64(len(k)))
+ i--
+ dAtA[i] = 0xa
+ i = encodeVarintLogservice(dAtA, i, uint64(baseI-i))
+ i--
+ dAtA[i] = 0xa
}
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
- }
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DNStoreInfo) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -3869,43 +4066,52 @@ func (m *DNStoreInfo) Marshal() (dAtA []byte, err error) {
}
func (m *DNStoreInfo) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DNStoreInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.Tick != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.Tick))
- }
- if len(m.ServiceAddress) > 0 {
- dAtA[i] = 0x12
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(len(m.ServiceAddress)))
- i += copy(dAtA[i:], m.ServiceAddress)
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Shards) > 0 {
- for _, msg := range m.Shards {
- dAtA[i] = 0x1a
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(msg.Size()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
+ for iNdEx := len(m.Shards) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Shards[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- i += n
+ i--
+ dAtA[i] = 0x1a
}
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.ServiceAddress) > 0 {
+ i -= len(m.ServiceAddress)
+ copy(dAtA[i:], m.ServiceAddress)
+ i = encodeVarintLogservice(dAtA, i, uint64(len(m.ServiceAddress)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if m.Tick != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.Tick))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DNState) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -3913,46 +4119,50 @@ func (m *DNState) Marshal() (dAtA []byte, err error) {
}
func (m *DNState) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DNState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if len(m.Stores) > 0 {
for k := range m.Stores {
- dAtA[i] = 0xa
- i++
v := m.Stores[k]
- msgSize := 0
- if (&v) != nil {
- msgSize = (&v).Size()
- msgSize += 1 + sovLogservice(uint64(msgSize))
+ baseI := i
+ {
+ size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- mapSize := 1 + len(k) + sovLogservice(uint64(len(k))) + msgSize
- i = encodeVarintLogservice(dAtA, i, uint64(mapSize))
- dAtA[i] = 0xa
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(len(k)))
- i += copy(dAtA[i:], k)
+ i--
dAtA[i] = 0x12
- i++
- i = encodeVarintLogservice(dAtA, i, uint64((&v).Size()))
- n15, err15 := (&v).MarshalTo(dAtA[i:])
- if err15 != nil {
- return 0, err15
- }
- i += n15
+ i -= len(k)
+ copy(dAtA[i:], k)
+ i = encodeVarintLogservice(dAtA, i, uint64(len(k)))
+ i--
+ dAtA[i] = 0xa
+ i = encodeVarintLogservice(dAtA, i, uint64(baseI-i))
+ i--
+ dAtA[i] = 0xa
}
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
- }
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *ClusterDetails) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -3960,44 +4170,54 @@ func (m *ClusterDetails) Marshal() (dAtA []byte, err error) {
}
func (m *ClusterDetails) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ClusterDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.DNNodes) > 0 {
- for _, msg := range m.DNNodes {
- dAtA[i] = 0xa
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(msg.Size()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
- }
- i += n
- }
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.CNNodes) > 0 {
- for _, msg := range m.CNNodes {
- dAtA[i] = 0x12
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(msg.Size()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
+ for iNdEx := len(m.CNNodes) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.CNNodes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- i += n
+ i--
+ dAtA[i] = 0x12
}
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.DNNodes) > 0 {
+ for iNdEx := len(m.DNNodes) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.DNNodes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0xa
+ }
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *ClusterInfo) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -4005,44 +4225,54 @@ func (m *ClusterInfo) Marshal() (dAtA []byte, err error) {
}
func (m *ClusterInfo) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ClusterInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.DNShards) > 0 {
- for _, msg := range m.DNShards {
- dAtA[i] = 0xa
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(msg.Size()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
- }
- i += n
- }
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.LogShards) > 0 {
- for _, msg := range m.LogShards {
- dAtA[i] = 0x12
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(msg.Size()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
+ for iNdEx := len(m.LogShards) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.LogShards[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- i += n
+ i--
+ dAtA[i] = 0x12
}
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.DNShards) > 0 {
+ for iNdEx := len(m.DNShards) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.DNShards[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0xa
+ }
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *InitialClusterRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -4050,35 +4280,41 @@ func (m *InitialClusterRequest) Marshal() (dAtA []byte, err error) {
}
func (m *InitialClusterRequest) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *InitialClusterRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.NumOfLogShards != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.NumOfLogShards))
- }
- if m.NumOfDNShards != 0 {
- dAtA[i] = 0x10
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.NumOfDNShards))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if m.NumOfLogReplicas != 0 {
- dAtA[i] = 0x18
- i++
i = encodeVarintLogservice(dAtA, i, uint64(m.NumOfLogReplicas))
+ i--
+ dAtA[i] = 0x18
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.NumOfDNShards != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.NumOfDNShards))
+ i--
+ dAtA[i] = 0x10
+ }
+ if m.NumOfLogShards != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.NumOfLogShards))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *LogStoreInfo) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -4086,55 +4322,66 @@ func (m *LogStoreInfo) Marshal() (dAtA []byte, err error) {
}
func (m *LogStoreInfo) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *LogStoreInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.Tick != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.Tick))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
+ if len(m.Replicas) > 0 {
+ for iNdEx := len(m.Replicas) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Replicas[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x2a
+ }
}
- if len(m.RaftAddress) > 0 {
- dAtA[i] = 0x12
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(len(m.RaftAddress)))
- i += copy(dAtA[i:], m.RaftAddress)
+ if len(m.GossipAddress) > 0 {
+ i -= len(m.GossipAddress)
+ copy(dAtA[i:], m.GossipAddress)
+ i = encodeVarintLogservice(dAtA, i, uint64(len(m.GossipAddress)))
+ i--
+ dAtA[i] = 0x22
}
if len(m.ServiceAddress) > 0 {
- dAtA[i] = 0x1a
- i++
+ i -= len(m.ServiceAddress)
+ copy(dAtA[i:], m.ServiceAddress)
i = encodeVarintLogservice(dAtA, i, uint64(len(m.ServiceAddress)))
- i += copy(dAtA[i:], m.ServiceAddress)
- }
- if len(m.GossipAddress) > 0 {
- dAtA[i] = 0x22
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(len(m.GossipAddress)))
- i += copy(dAtA[i:], m.GossipAddress)
+ i--
+ dAtA[i] = 0x1a
}
- if len(m.Replicas) > 0 {
- for _, msg := range m.Replicas {
- dAtA[i] = 0x2a
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(msg.Size()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
- }
- i += n
- }
+ if len(m.RaftAddress) > 0 {
+ i -= len(m.RaftAddress)
+ copy(dAtA[i:], m.RaftAddress)
+ i = encodeVarintLogservice(dAtA, i, uint64(len(m.RaftAddress)))
+ i--
+ dAtA[i] = 0x12
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.Tick != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.Tick))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *LogState) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -4142,71 +4389,72 @@ func (m *LogState) Marshal() (dAtA []byte, err error) {
}
func (m *LogState) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *LogState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.Shards) > 0 {
- for k := range m.Shards {
- dAtA[i] = 0xa
- i++
- v := m.Shards[k]
- msgSize := 0
- if (&v) != nil {
- msgSize = (&v).Size()
- msgSize += 1 + sovLogservice(uint64(msgSize))
- }
- mapSize := 1 + sovLogservice(uint64(k)) + msgSize
- i = encodeVarintLogservice(dAtA, i, uint64(mapSize))
- dAtA[i] = 0x8
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(k))
- dAtA[i] = 0x12
- i++
- i = encodeVarintLogservice(dAtA, i, uint64((&v).Size()))
- n16, err16 := (&v).MarshalTo(dAtA[i:])
- if err16 != nil {
- return 0, err16
- }
- i += n16
- }
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Stores) > 0 {
for k := range m.Stores {
- dAtA[i] = 0x12
- i++
v := m.Stores[k]
- msgSize := 0
- if (&v) != nil {
- msgSize = (&v).Size()
- msgSize += 1 + sovLogservice(uint64(msgSize))
+ baseI := i
+ {
+ size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- mapSize := 1 + len(k) + sovLogservice(uint64(len(k))) + msgSize
- i = encodeVarintLogservice(dAtA, i, uint64(mapSize))
- dAtA[i] = 0xa
- i++
+ i--
+ dAtA[i] = 0x12
+ i -= len(k)
+ copy(dAtA[i:], k)
i = encodeVarintLogservice(dAtA, i, uint64(len(k)))
- i += copy(dAtA[i:], k)
+ i--
+ dAtA[i] = 0xa
+ i = encodeVarintLogservice(dAtA, i, uint64(baseI-i))
+ i--
dAtA[i] = 0x12
- i++
- i = encodeVarintLogservice(dAtA, i, uint64((&v).Size()))
- n17, err17 := (&v).MarshalTo(dAtA[i:])
- if err17 != nil {
- return 0, err17
- }
- i += n17
}
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.Shards) > 0 {
+ for k := range m.Shards {
+ v := m.Shards[k]
+ baseI := i
+ {
+ size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x12
+ i = encodeVarintLogservice(dAtA, i, uint64(k))
+ i--
+ dAtA[i] = 0x8
+ i = encodeVarintLogservice(dAtA, i, uint64(baseI-i))
+ i--
+ dAtA[i] = 0xa
+ }
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *CheckerState) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -4214,54 +4462,66 @@ func (m *CheckerState) Marshal() (dAtA []byte, err error) {
}
func (m *CheckerState) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CheckerState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.Tick != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.Tick))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- dAtA[i] = 0x12
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.ClusterInfo.Size()))
- n18, err18 := m.ClusterInfo.MarshalTo(dAtA[i:])
- if err18 != nil {
- return 0, err18
+ if m.State != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.State))
+ i--
+ dAtA[i] = 0x28
}
- i += n18
- dAtA[i] = 0x1a
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.DNState.Size()))
- n19, err19 := m.DNState.MarshalTo(dAtA[i:])
- if err19 != nil {
- return 0, err19
+ {
+ size, err := m.LogState.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- i += n19
+ i--
dAtA[i] = 0x22
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.LogState.Size()))
- n20, err20 := m.LogState.MarshalTo(dAtA[i:])
- if err20 != nil {
- return 0, err20
+ {
+ size, err := m.DNState.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- i += n20
- if m.State != 0 {
- dAtA[i] = 0x28
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.State))
+ i--
+ dAtA[i] = 0x1a
+ {
+ size, err := m.ClusterInfo.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0x12
+ if m.Tick != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.Tick))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *HAKeeperRSMState) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -4269,118 +4529,133 @@ func (m *HAKeeperRSMState) Marshal() (dAtA []byte, err error) {
}
func (m *HAKeeperRSMState) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *HAKeeperRSMState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.Tick != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.Tick))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if m.NextID != 0 {
- dAtA[i] = 0x10
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.NextID))
+ {
+ size, err := m.ClusterInfo.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- if m.Term != 0 {
- dAtA[i] = 0x18
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.Term))
+ i--
+ dAtA[i] = 0x52
+ {
+ size, err := m.LogState.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- if m.State != 0 {
- dAtA[i] = 0x20
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.State))
+ i--
+ dAtA[i] = 0x4a
+ {
+ size, err := m.DNState.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
- if len(m.ScheduleCommands) > 0 {
- for k := range m.ScheduleCommands {
- dAtA[i] = 0x2a
- i++
- v := m.ScheduleCommands[k]
- msgSize := 0
- if (&v) != nil {
- msgSize = (&v).Size()
- msgSize += 1 + sovLogservice(uint64(msgSize))
- }
- mapSize := 1 + len(k) + sovLogservice(uint64(len(k))) + msgSize
- i = encodeVarintLogservice(dAtA, i, uint64(mapSize))
- dAtA[i] = 0xa
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(len(k)))
- i += copy(dAtA[i:], k)
- dAtA[i] = 0x12
- i++
- i = encodeVarintLogservice(dAtA, i, uint64((&v).Size()))
- n21, err21 := (&v).MarshalTo(dAtA[i:])
- if err21 != nil {
- return 0, err21
- }
- i += n21
+ i--
+ dAtA[i] = 0x42
+ {
+ size, err := m.CNState.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
}
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
}
+ i--
+ dAtA[i] = 0x3a
if len(m.LogShards) > 0 {
for k := range m.LogShards {
- dAtA[i] = 0x32
- i++
v := m.LogShards[k]
- mapSize := 1 + len(k) + sovLogservice(uint64(len(k))) + 1 + sovLogservice(uint64(v))
- i = encodeVarintLogservice(dAtA, i, uint64(mapSize))
- dAtA[i] = 0xa
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(len(k)))
- i += copy(dAtA[i:], k)
- dAtA[i] = 0x10
- i++
+ baseI := i
i = encodeVarintLogservice(dAtA, i, uint64(v))
+ i--
+ dAtA[i] = 0x10
+ i -= len(k)
+ copy(dAtA[i:], k)
+ i = encodeVarintLogservice(dAtA, i, uint64(len(k)))
+ i--
+ dAtA[i] = 0xa
+ i = encodeVarintLogservice(dAtA, i, uint64(baseI-i))
+ i--
+ dAtA[i] = 0x32
}
}
- dAtA[i] = 0x3a
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.CNState.Size()))
- n22, err22 := m.CNState.MarshalTo(dAtA[i:])
- if err22 != nil {
- return 0, err22
+ if len(m.ScheduleCommands) > 0 {
+ for k := range m.ScheduleCommands {
+ v := m.ScheduleCommands[k]
+ baseI := i
+ {
+ size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintLogservice(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x12
+ i -= len(k)
+ copy(dAtA[i:], k)
+ i = encodeVarintLogservice(dAtA, i, uint64(len(k)))
+ i--
+ dAtA[i] = 0xa
+ i = encodeVarintLogservice(dAtA, i, uint64(baseI-i))
+ i--
+ dAtA[i] = 0x2a
+ }
}
- i += n22
- dAtA[i] = 0x42
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.DNState.Size()))
- n23, err23 := m.DNState.MarshalTo(dAtA[i:])
- if err23 != nil {
- return 0, err23
+ if m.State != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.State))
+ i--
+ dAtA[i] = 0x20
}
- i += n23
- dAtA[i] = 0x4a
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.LogState.Size()))
- n24, err24 := m.LogState.MarshalTo(dAtA[i:])
- if err24 != nil {
- return 0, err24
+ if m.Term != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.Term))
+ i--
+ dAtA[i] = 0x18
}
- i += n24
- dAtA[i] = 0x52
- i++
- i = encodeVarintLogservice(dAtA, i, uint64(m.ClusterInfo.Size()))
- n25, err25 := m.ClusterInfo.MarshalTo(dAtA[i:])
- if err25 != nil {
- return 0, err25
+ if m.NextID != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.NextID))
+ i--
+ dAtA[i] = 0x10
}
- i += n25
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.Tick != 0 {
+ i = encodeVarintLogservice(dAtA, i, uint64(m.Tick))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func encodeVarintLogservice(dAtA []byte, offset int, v uint64) int {
+ offset -= sovLogservice(v)
+ base := offset
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
- return offset + 1
+ return base
}
func (m *CNNode) Size() (n int) {
if m == nil {
@@ -5331,10 +5606,7 @@ func (m *CNNode) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -5468,10 +5740,7 @@ func (m *DNNode) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -5637,7 +5906,7 @@ func (m *LogShardInfo) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > postIndex {
@@ -5711,10 +5980,7 @@ func (m *LogShardInfo) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -5817,10 +6083,7 @@ func (m *LogReplicaInfo) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -5935,10 +6198,7 @@ func (m *CNStoreHeartbeat) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -6151,10 +6411,7 @@ func (m *LogStoreHeartbeat) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -6243,10 +6500,7 @@ func (m *DNShardInfo) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -6395,10 +6649,7 @@ func (m *DNStoreHeartbeat) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -6607,7 +6858,7 @@ func (m *RSMState) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > postIndex {
@@ -6624,10 +6875,7 @@ func (m *RSMState) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -6750,10 +6998,7 @@ func (m *LogRecord) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -6931,10 +7176,7 @@ func (m *LogRequest) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -7004,10 +7246,7 @@ func (m *TsoRequest) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -7280,10 +7519,7 @@ func (m *Request) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -7391,10 +7627,7 @@ func (m *LogResponse) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -7686,10 +7919,7 @@ func (m *Response) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -7774,10 +8004,7 @@ func (m *LogRecordResponse) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -7847,10 +8074,7 @@ func (m *TsoResponse) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -8009,10 +8233,7 @@ func (m *Replica) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -8211,7 +8432,7 @@ func (m *ConfigChange) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > postIndex {
@@ -8228,10 +8449,7 @@ func (m *ConfigChange) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -8314,10 +8532,7 @@ func (m *ShutdownStore) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -8511,10 +8726,7 @@ func (m *ScheduleCommand) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -8618,10 +8830,7 @@ func (m *CommandBatch) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -8723,10 +8932,7 @@ func (m *CNStoreInfo) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -8889,7 +9095,7 @@ func (m *CNState) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > postIndex {
@@ -8906,10 +9112,7 @@ func (m *CNState) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -9045,10 +9248,7 @@ func (m *DNStoreInfo) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -9211,7 +9411,7 @@ func (m *DNState) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > postIndex {
@@ -9228,10 +9428,7 @@ func (m *DNState) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -9350,10 +9547,7 @@ func (m *ClusterDetails) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -9472,10 +9666,7 @@ func (m *ClusterInfo) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -9583,10 +9774,7 @@ func (m *InitialClusterRequest) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -9786,10 +9974,7 @@ func (m *LogStoreInfo) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -9938,7 +10123,7 @@ func (m *LogState) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > postIndex {
@@ -10067,7 +10252,7 @@ func (m *LogState) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > postIndex {
@@ -10084,10 +10269,7 @@ func (m *LogState) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -10275,10 +10457,7 @@ func (m *CheckerState) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -10517,7 +10696,7 @@ func (m *HAKeeperRSMState) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > postIndex {
@@ -10630,7 +10809,7 @@ func (m *HAKeeperRSMState) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > postIndex {
@@ -10779,10 +10958,7 @@ func (m *HAKeeperRSMState) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthLogservice
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLogservice
}
if (iNdEx + skippy) > l {
@@ -10801,6 +10977,7 @@ func (m *HAKeeperRSMState) Unmarshal(dAtA []byte) error {
func skipLogservice(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
+ depth := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
@@ -10832,10 +11009,8 @@ func skipLogservice(dAtA []byte) (n int, err error) {
break
}
}
- return iNdEx, nil
case 1:
iNdEx += 8
- return iNdEx, nil
case 2:
var length int
for shift := uint(0); ; shift += 7 {
@@ -10856,55 +11031,30 @@ func skipLogservice(dAtA []byte) (n int, err error) {
return 0, ErrInvalidLengthLogservice
}
iNdEx += length
- if iNdEx < 0 {
- return 0, ErrInvalidLengthLogservice
- }
- return iNdEx, nil
case 3:
- for {
- var innerWire uint64
- var start int = iNdEx
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return 0, ErrIntOverflowLogservice
- }
- if iNdEx >= l {
- return 0, io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- innerWire |= (uint64(b) & 0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- innerWireType := int(innerWire & 0x7)
- if innerWireType == 4 {
- break
- }
- next, err := skipLogservice(dAtA[start:])
- if err != nil {
- return 0, err
- }
- iNdEx = start + next
- if iNdEx < 0 {
- return 0, ErrInvalidLengthLogservice
- }
- }
- return iNdEx, nil
+ depth++
case 4:
- return iNdEx, nil
+ if depth == 0 {
+ return 0, ErrUnexpectedEndOfGroupLogservice
+ }
+ depth--
case 5:
iNdEx += 4
- return iNdEx, nil
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
+ if iNdEx < 0 {
+ return 0, ErrInvalidLengthLogservice
+ }
+ if depth == 0 {
+ return iNdEx, nil
+ }
}
- panic("unreachable")
+ return 0, io.ErrUnexpectedEOF
}
var (
- ErrInvalidLengthLogservice = fmt.Errorf("proto: negative length found during unmarshaling")
- ErrIntOverflowLogservice = fmt.Errorf("proto: integer overflow")
+ ErrInvalidLengthLogservice = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowLogservice = fmt.Errorf("proto: integer overflow")
+ ErrUnexpectedEndOfGroupLogservice = fmt.Errorf("proto: unexpected end of group")
)
diff --git a/pkg/pb/metadata/metadata.pb.go b/pkg/pb/metadata/metadata.pb.go
index 822c7cc0c8fc0ed91020c60dd99f02100d3a8e1d..2a72939dcebf85479b2f3bfbd8ed8295e6c07186 100644
--- a/pkg/pb/metadata/metadata.pb.go
+++ b/pkg/pb/metadata/metadata.pb.go
@@ -22,7 +22,7 @@ var _ = math.Inf
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
// DNShardRecord is DN shard metadata describing what is a DN shard. It
// is internally used by HAKeeper to maintain how many DNs available in
@@ -51,7 +51,7 @@ func (m *DNShardRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
return xxx_messageInfo_DNShardRecord.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -113,7 +113,7 @@ func (m *DNShard) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DNShard.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -175,7 +175,7 @@ func (m *LogShardRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro
return xxx_messageInfo_LogShardRecord.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -215,40 +215,101 @@ func (m *LogShardRecord) GetName() string {
return ""
}
+// DNStore DN store metadata
+type DNStore struct {
+ // UUID DNStore uuid id
+ UUID string `protobuf:"bytes,1,opt,name=UUID,proto3" json:"UUID,omitempty"`
+ // Shards DNShards
+ Shards []DNShard `protobuf:"bytes,2,rep,name=Shards,proto3" json:"Shards"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *DNStore) Reset() { *m = DNStore{} }
+func (m *DNStore) String() string { return proto.CompactTextString(m) }
+func (*DNStore) ProtoMessage() {}
+func (*DNStore) Descriptor() ([]byte, []int) {
+ return fileDescriptor_56d9f74966f40d04, []int{3}
+}
+func (m *DNStore) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *DNStore) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_DNStore.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *DNStore) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_DNStore.Merge(m, src)
+}
+func (m *DNStore) XXX_Size() int {
+ return m.Size()
+}
+func (m *DNStore) XXX_DiscardUnknown() {
+ xxx_messageInfo_DNStore.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DNStore proto.InternalMessageInfo
+
+func (m *DNStore) GetUUID() string {
+ if m != nil {
+ return m.UUID
+ }
+ return ""
+}
+
+func (m *DNStore) GetShards() []DNShard {
+ if m != nil {
+ return m.Shards
+ }
+ return nil
+}
+
func init() {
proto.RegisterType((*DNShardRecord)(nil), "metadata.DNShardRecord")
proto.RegisterType((*DNShard)(nil), "metadata.DNShard")
proto.RegisterType((*LogShardRecord)(nil), "metadata.LogShardRecord")
+ proto.RegisterType((*DNStore)(nil), "metadata.DNStore")
}
func init() { proto.RegisterFile("metadata.proto", fileDescriptor_56d9f74966f40d04) }
var fileDescriptor_56d9f74966f40d04 = []byte{
- // 279 bytes of a gzipped FileDescriptorProto
- 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0xcb, 0x4d, 0x2d, 0x49,
- 0x4c, 0x49, 0x2c, 0x49, 0xd4, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x80, 0xf1, 0xa5, 0x74,
- 0xd3, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0xd3, 0xf3, 0xd3, 0xf3, 0xf5,
- 0xc1, 0x0a, 0x92, 0x4a, 0xd3, 0xc0, 0x3c, 0x30, 0x07, 0xcc, 0x82, 0x68, 0x54, 0xf2, 0xe4, 0xe2,
- 0x75, 0xf1, 0x0b, 0xce, 0x48, 0x2c, 0x4a, 0x09, 0x4a, 0x4d, 0xce, 0x2f, 0x4a, 0x11, 0x92, 0xe0,
- 0x62, 0x07, 0x73, 0x3d, 0x5d, 0x24, 0x18, 0x15, 0x18, 0x35, 0x58, 0x82, 0x60, 0x5c, 0x21, 0x39,
- 0x2e, 0x2e, 0x9f, 0xfc, 0x74, 0x98, 0x24, 0x13, 0x58, 0x12, 0x49, 0x44, 0xa9, 0x8b, 0x91, 0x8b,
- 0x1d, 0x6a, 0x96, 0x90, 0x3b, 0x9a, 0xb1, 0x60, 0xb3, 0xb8, 0x8d, 0xc4, 0xf5, 0xe0, 0xee, 0x46,
- 0x91, 0x76, 0xe2, 0x38, 0x71, 0x4f, 0x9e, 0xe1, 0xc2, 0x3d, 0x79, 0xc6, 0x20, 0x34, 0xe7, 0xc8,
- 0x70, 0x71, 0x06, 0xa5, 0x16, 0xe4, 0x64, 0x26, 0x27, 0xc2, 0xed, 0x44, 0x08, 0x80, 0x1c, 0xeb,
- 0x98, 0x92, 0x52, 0x94, 0x5a, 0x5c, 0x2c, 0xc1, 0xac, 0xc0, 0xa8, 0xc1, 0x19, 0x04, 0xe3, 0x2a,
- 0x65, 0x71, 0xf1, 0xc1, 0x9c, 0x46, 0xd0, 0x63, 0x5a, 0x5c, 0x02, 0x7e, 0xa5, 0xb9, 0x49, 0xa9,
- 0x45, 0xfe, 0x69, 0x50, 0xa3, 0x8b, 0xa1, 0x56, 0x61, 0x88, 0x0b, 0x09, 0x71, 0xb1, 0xf8, 0x25,
- 0xe6, 0xa6, 0x42, 0xad, 0x03, 0xb3, 0x9d, 0xec, 0x4f, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e,
- 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x28, 0x43, 0xa4, 0x08, 0xc8, 0x4d, 0x2c, 0x29, 0xca, 0xac, 0xc8,
- 0x2f, 0xca, 0x4c, 0xcf, 0xcc, 0x83, 0x71, 0xf2, 0x52, 0xf5, 0x0b, 0xb2, 0xd3, 0xf5, 0x0b, 0x92,
- 0xf4, 0x61, 0x61, 0x91, 0xc4, 0x06, 0x8e, 0x0b, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x56,
- 0xc5, 0x4d, 0x2e, 0xd6, 0x01, 0x00, 0x00,
+ // 317 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x51, 0xcd, 0x4a, 0x03, 0x31,
+ 0x10, 0x36, 0xb6, 0xf4, 0x27, 0xc5, 0xa2, 0xb9, 0x58, 0x44, 0xb6, 0x65, 0x4f, 0x45, 0xb0, 0xc1,
+ 0xfa, 0x00, 0x62, 0x29, 0x48, 0x41, 0x56, 0x88, 0xf4, 0xe2, 0x2d, 0xdb, 0x4d, 0xd3, 0x55, 0xb7,
+ 0x59, 0xb2, 0x59, 0xf0, 0x19, 0x7c, 0xb2, 0x1e, 0xfb, 0x04, 0x45, 0xf6, 0x49, 0x64, 0xc7, 0xa4,
+ 0xd6, 0xf6, 0xe0, 0x6d, 0xbe, 0xf9, 0x26, 0xdf, 0xf7, 0x4d, 0x06, 0xb7, 0x13, 0x61, 0x78, 0xc4,
+ 0x0d, 0x1f, 0xa4, 0x5a, 0x19, 0x45, 0x1a, 0x0e, 0x5f, 0x5c, 0xcb, 0xd8, 0x2c, 0xf2, 0x70, 0x30,
+ 0x53, 0x09, 0x95, 0x4a, 0x2a, 0x0a, 0x03, 0x61, 0x3e, 0x07, 0x04, 0x00, 0xaa, 0x9f, 0x87, 0xfe,
+ 0x04, 0x9f, 0x8c, 0x83, 0xe7, 0x05, 0xd7, 0x11, 0x13, 0x33, 0xa5, 0x23, 0xd2, 0xc1, 0x75, 0x80,
+ 0x93, 0x71, 0x07, 0xf5, 0x50, 0xbf, 0xca, 0x1c, 0x24, 0x1e, 0xc6, 0x8f, 0x4a, 0x3a, 0xf2, 0x18,
+ 0xc8, 0x9d, 0x8e, 0xff, 0x89, 0x70, 0xdd, 0x6a, 0x91, 0x87, 0x3d, 0x59, 0xd0, 0x6a, 0x0d, 0xcf,
+ 0x07, 0xdb, 0xdc, 0x7f, 0xe8, 0x51, 0x63, 0xb5, 0xe9, 0x1e, 0xad, 0x37, 0x5d, 0xc4, 0xf6, 0xe2,
+ 0x5c, 0xe2, 0x26, 0x13, 0xe9, 0x7b, 0x3c, 0xe3, 0x5b, 0xcf, 0xdf, 0x46, 0x19, 0xf6, 0x3e, 0x8a,
+ 0xb4, 0xc8, 0xb2, 0x4e, 0xa5, 0x87, 0xfa, 0x4d, 0xe6, 0xa0, 0xff, 0x8a, 0xdb, 0x2e, 0xda, 0xbf,
+ 0x8b, 0x5d, 0xe1, 0xd3, 0x20, 0x4f, 0x42, 0xa1, 0x9f, 0xe6, 0x56, 0x3a, 0xb3, 0x56, 0x07, 0x7d,
+ 0x42, 0x70, 0x35, 0xe0, 0x89, 0xb0, 0x76, 0x50, 0xfb, 0x01, 0xec, 0x6d, 0x94, 0x16, 0x25, 0x3d,
+ 0x9d, 0x5a, 0x87, 0x26, 0x83, 0x9a, 0x50, 0x5c, 0x03, 0xa7, 0x52, 0xb4, 0xd2, 0x6f, 0x0d, 0xcf,
+ 0x0e, 0x3e, 0x61, 0x54, 0x2d, 0xd7, 0x67, 0x76, 0x6c, 0x74, 0xb7, 0x2a, 0x3c, 0xb4, 0x2e, 0x3c,
+ 0xf4, 0x55, 0x78, 0xe8, 0xe5, 0x66, 0xe7, 0xa0, 0x09, 0x37, 0x3a, 0xfe, 0x50, 0x3a, 0x96, 0xf1,
+ 0xd2, 0x81, 0xa5, 0xa0, 0xe9, 0x9b, 0xa4, 0x69, 0x48, 0x9d, 0x6c, 0x58, 0x83, 0xdb, 0xde, 0x7e,
+ 0x07, 0x00, 0x00, 0xff, 0xff, 0x5b, 0xd0, 0xb2, 0x72, 0x26, 0x02, 0x00, 0x00,
}
func (m *DNShardRecord) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -256,30 +317,36 @@ func (m *DNShardRecord) Marshal() (dAtA []byte, err error) {
}
func (m *DNShardRecord) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DNShardRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.ShardID != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintMetadata(dAtA, i, uint64(m.ShardID))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if m.LogShardID != 0 {
- dAtA[i] = 0x10
- i++
i = encodeVarintMetadata(dAtA, i, uint64(m.LogShardID))
+ i--
+ dAtA[i] = 0x10
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.ShardID != 0 {
+ i = encodeVarintMetadata(dAtA, i, uint64(m.ShardID))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DNShard) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -287,39 +354,48 @@ func (m *DNShard) Marshal() (dAtA []byte, err error) {
}
func (m *DNShard) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DNShard) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- dAtA[i] = 0xa
- i++
- i = encodeVarintMetadata(dAtA, i, uint64(m.DNShardRecord.Size()))
- n1, err1 := m.DNShardRecord.MarshalTo(dAtA[i:])
- if err1 != nil {
- return 0, err1
- }
- i += n1
- if m.ReplicaID != 0 {
- dAtA[i] = 0x10
- i++
- i = encodeVarintMetadata(dAtA, i, uint64(m.ReplicaID))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Address) > 0 {
- dAtA[i] = 0x1a
- i++
+ i -= len(m.Address)
+ copy(dAtA[i:], m.Address)
i = encodeVarintMetadata(dAtA, i, uint64(len(m.Address)))
- i += copy(dAtA[i:], m.Address)
+ i--
+ dAtA[i] = 0x1a
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.ReplicaID != 0 {
+ i = encodeVarintMetadata(dAtA, i, uint64(m.ReplicaID))
+ i--
+ dAtA[i] = 0x10
}
- return i, nil
+ {
+ size, err := m.DNShardRecord.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintMetadata(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0xa
+ return len(dAtA) - i, nil
}
func (m *LogShardRecord) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -327,40 +403,97 @@ func (m *LogShardRecord) Marshal() (dAtA []byte, err error) {
}
func (m *LogShardRecord) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *LogShardRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.ShardID != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintMetadata(dAtA, i, uint64(m.ShardID))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
+ if len(m.Name) > 0 {
+ i -= len(m.Name)
+ copy(dAtA[i:], m.Name)
+ i = encodeVarintMetadata(dAtA, i, uint64(len(m.Name)))
+ i--
+ dAtA[i] = 0x1a
}
if m.NumberOfReplicas != 0 {
- dAtA[i] = 0x10
- i++
i = encodeVarintMetadata(dAtA, i, uint64(m.NumberOfReplicas))
+ i--
+ dAtA[i] = 0x10
}
- if len(m.Name) > 0 {
- dAtA[i] = 0x1a
- i++
- i = encodeVarintMetadata(dAtA, i, uint64(len(m.Name)))
- i += copy(dAtA[i:], m.Name)
+ if m.ShardID != 0 {
+ i = encodeVarintMetadata(dAtA, i, uint64(m.ShardID))
+ i--
+ dAtA[i] = 0x8
}
+ return len(dAtA) - i, nil
+}
+
+func (m *DNStore) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *DNStore) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DNStore) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
+ if len(m.Shards) > 0 {
+ for iNdEx := len(m.Shards) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Shards[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintMetadata(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x12
+ }
+ }
+ if len(m.UUID) > 0 {
+ i -= len(m.UUID)
+ copy(dAtA[i:], m.UUID)
+ i = encodeVarintMetadata(dAtA, i, uint64(len(m.UUID)))
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func encodeVarintMetadata(dAtA []byte, offset int, v uint64) int {
+ offset -= sovMetadata(v)
+ base := offset
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
- return offset + 1
+ return base
}
func (m *DNShardRecord) Size() (n int) {
if m == nil {
@@ -423,6 +556,28 @@ func (m *LogShardRecord) Size() (n int) {
return n
}
+func (m *DNStore) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.UUID)
+ if l > 0 {
+ n += 1 + l + sovMetadata(uint64(l))
+ }
+ if len(m.Shards) > 0 {
+ for _, e := range m.Shards {
+ l = e.Size()
+ n += 1 + l + sovMetadata(uint64(l))
+ }
+ }
+ if m.XXX_unrecognized != nil {
+ n += len(m.XXX_unrecognized)
+ }
+ return n
+}
+
func sovMetadata(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
@@ -502,10 +657,7 @@ func (m *DNShardRecord) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthMetadata
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthMetadata
}
if (iNdEx + skippy) > l {
@@ -640,10 +792,7 @@ func (m *DNShard) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthMetadata
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthMetadata
}
if (iNdEx + skippy) > l {
@@ -764,10 +913,124 @@ func (m *LogShardRecord) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthMetadata
}
- if (iNdEx + skippy) < 0 {
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *DNStore) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowMetadata
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: DNStore: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: DNStore: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field UUID", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowMetadata
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthMetadata
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthMetadata
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.UUID = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Shards", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowMetadata
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ msglen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthMetadata
+ }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthMetadata
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Shards = append(m.Shards, DNShard{})
+ if err := m.Shards[len(m.Shards)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipMetadata(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthMetadata
}
if (iNdEx + skippy) > l {
@@ -786,6 +1049,7 @@ func (m *LogShardRecord) Unmarshal(dAtA []byte) error {
func skipMetadata(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
+ depth := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
@@ -817,10 +1081,8 @@ func skipMetadata(dAtA []byte) (n int, err error) {
break
}
}
- return iNdEx, nil
case 1:
iNdEx += 8
- return iNdEx, nil
case 2:
var length int
for shift := uint(0); ; shift += 7 {
@@ -841,55 +1103,30 @@ func skipMetadata(dAtA []byte) (n int, err error) {
return 0, ErrInvalidLengthMetadata
}
iNdEx += length
- if iNdEx < 0 {
- return 0, ErrInvalidLengthMetadata
- }
- return iNdEx, nil
case 3:
- for {
- var innerWire uint64
- var start int = iNdEx
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return 0, ErrIntOverflowMetadata
- }
- if iNdEx >= l {
- return 0, io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- innerWire |= (uint64(b) & 0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- innerWireType := int(innerWire & 0x7)
- if innerWireType == 4 {
- break
- }
- next, err := skipMetadata(dAtA[start:])
- if err != nil {
- return 0, err
- }
- iNdEx = start + next
- if iNdEx < 0 {
- return 0, ErrInvalidLengthMetadata
- }
- }
- return iNdEx, nil
+ depth++
case 4:
- return iNdEx, nil
+ if depth == 0 {
+ return 0, ErrUnexpectedEndOfGroupMetadata
+ }
+ depth--
case 5:
iNdEx += 4
- return iNdEx, nil
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
+ if iNdEx < 0 {
+ return 0, ErrInvalidLengthMetadata
+ }
+ if depth == 0 {
+ return iNdEx, nil
+ }
}
- panic("unreachable")
+ return 0, io.ErrUnexpectedEOF
}
var (
- ErrInvalidLengthMetadata = fmt.Errorf("proto: negative length found during unmarshaling")
- ErrIntOverflowMetadata = fmt.Errorf("proto: integer overflow")
+ ErrInvalidLengthMetadata = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowMetadata = fmt.Errorf("proto: integer overflow")
+ ErrUnexpectedEndOfGroupMetadata = fmt.Errorf("proto: unexpected end of group")
)
diff --git a/pkg/pb/metric/metric.pb.go b/pkg/pb/metric/metric.pb.go
index 7cda534e6aa6f28b8f1439d21ca42af9e00ede63..5b8b208de50e70e4c747c39cb9bc8d1eb77e9b0d 100644
--- a/pkg/pb/metric/metric.pb.go
+++ b/pkg/pb/metric/metric.pb.go
@@ -22,7 +22,7 @@ var _ = math.Inf
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
type MetricType int32
@@ -74,7 +74,7 @@ func (m *LabelPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_LabelPair.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -128,7 +128,7 @@ func (m *Gauge) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Gauge.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -175,7 +175,7 @@ func (m *Counter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Counter.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -223,7 +223,7 @@ func (m *Sample) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Sample.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -277,7 +277,7 @@ func (m *RawHist) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_RawHist.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -328,7 +328,7 @@ func (m *Metric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Metric.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -408,7 +408,7 @@ func (m *MetricFamily) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_MetricFamily.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -517,7 +517,7 @@ var fileDescriptor_da41641f55bff5df = []byte{
func (m *LabelPair) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -525,32 +525,40 @@ func (m *LabelPair) Marshal() (dAtA []byte, err error) {
}
func (m *LabelPair) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *LabelPair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.Name) > 0 {
- dAtA[i] = 0xa
- i++
- i = encodeVarintMetric(dAtA, i, uint64(len(m.Name)))
- i += copy(dAtA[i:], m.Name)
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Value) > 0 {
- dAtA[i] = 0x12
- i++
+ i -= len(m.Value)
+ copy(dAtA[i:], m.Value)
i = encodeVarintMetric(dAtA, i, uint64(len(m.Value)))
- i += copy(dAtA[i:], m.Value)
+ i--
+ dAtA[i] = 0x12
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.Name) > 0 {
+ i -= len(m.Name)
+ copy(dAtA[i:], m.Name)
+ i = encodeVarintMetric(dAtA, i, uint64(len(m.Name)))
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Gauge) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -558,26 +566,32 @@ func (m *Gauge) Marshal() (dAtA []byte, err error) {
}
func (m *Gauge) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Gauge) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if m.Value != 0 {
- dAtA[i] = 0x9
- i++
+ i -= 8
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Value))))
- i += 8
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0x9
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Counter) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -585,26 +599,32 @@ func (m *Counter) Marshal() (dAtA []byte, err error) {
}
func (m *Counter) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Counter) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if m.Value != 0 {
- dAtA[i] = 0x9
- i++
+ i -= 8
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Value))))
- i += 8
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0x9
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Sample) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -612,31 +632,37 @@ func (m *Sample) Marshal() (dAtA []byte, err error) {
}
func (m *Sample) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Sample) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.Datetime != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintMetric(dAtA, i, uint64(m.Datetime))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if m.Value != 0 {
- dAtA[i] = 0x11
- i++
+ i -= 8
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Value))))
- i += 8
+ i--
+ dAtA[i] = 0x11
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.Datetime != 0 {
+ i = encodeVarintMetric(dAtA, i, uint64(m.Datetime))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *RawHist) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -644,32 +670,40 @@ func (m *RawHist) Marshal() (dAtA []byte, err error) {
}
func (m *RawHist) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *RawHist) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if len(m.Samples) > 0 {
- for _, msg := range m.Samples {
- dAtA[i] = 0xa
- i++
- i = encodeVarintMetric(dAtA, i, uint64(msg.Size()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
+ for iNdEx := len(m.Samples) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Samples[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintMetric(dAtA, i, uint64(size))
}
- i += n
+ i--
+ dAtA[i] = 0xa
}
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
- }
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Metric) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -677,67 +711,81 @@ func (m *Metric) Marshal() (dAtA []byte, err error) {
}
func (m *Metric) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Metric) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.Label) > 0 {
- for _, msg := range m.Label {
- dAtA[i] = 0xa
- i++
- i = encodeVarintMetric(dAtA, i, uint64(msg.Size()))
- n, err := msg.MarshalTo(dAtA[i:])
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
+ if m.Collecttime != 0 {
+ i = encodeVarintMetric(dAtA, i, uint64(m.Collecttime))
+ i--
+ dAtA[i] = 0x28
+ }
+ if m.RawHist != nil {
+ {
+ size, err := m.RawHist.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
- i += n
+ i -= size
+ i = encodeVarintMetric(dAtA, i, uint64(size))
}
- }
- if m.Gauge != nil {
- dAtA[i] = 0x12
- i++
- i = encodeVarintMetric(dAtA, i, uint64(m.Gauge.Size()))
- n1, err1 := m.Gauge.MarshalTo(dAtA[i:])
- if err1 != nil {
- return 0, err1
- }
- i += n1
+ i--
+ dAtA[i] = 0x22
}
if m.Counter != nil {
- dAtA[i] = 0x1a
- i++
- i = encodeVarintMetric(dAtA, i, uint64(m.Counter.Size()))
- n2, err2 := m.Counter.MarshalTo(dAtA[i:])
- if err2 != nil {
- return 0, err2
+ {
+ size, err := m.Counter.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintMetric(dAtA, i, uint64(size))
}
- i += n2
+ i--
+ dAtA[i] = 0x1a
}
- if m.RawHist != nil {
- dAtA[i] = 0x22
- i++
- i = encodeVarintMetric(dAtA, i, uint64(m.RawHist.Size()))
- n3, err3 := m.RawHist.MarshalTo(dAtA[i:])
- if err3 != nil {
- return 0, err3
+ if m.Gauge != nil {
+ {
+ size, err := m.Gauge.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintMetric(dAtA, i, uint64(size))
}
- i += n3
- }
- if m.Collecttime != 0 {
- dAtA[i] = 0x28
- i++
- i = encodeVarintMetric(dAtA, i, uint64(m.Collecttime))
+ i--
+ dAtA[i] = 0x12
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.Label) > 0 {
+ for iNdEx := len(m.Label) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Label[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintMetric(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0xa
+ }
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *MetricFamily) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -745,64 +793,77 @@ func (m *MetricFamily) Marshal() (dAtA []byte, err error) {
}
func (m *MetricFamily) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MetricFamily) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.Name) > 0 {
- dAtA[i] = 0xa
- i++
- i = encodeVarintMetric(dAtA, i, uint64(len(m.Name)))
- i += copy(dAtA[i:], m.Name)
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if len(m.Help) > 0 {
- dAtA[i] = 0x12
- i++
- i = encodeVarintMetric(dAtA, i, uint64(len(m.Help)))
- i += copy(dAtA[i:], m.Help)
+ if len(m.Role) > 0 {
+ i -= len(m.Role)
+ copy(dAtA[i:], m.Role)
+ i = encodeVarintMetric(dAtA, i, uint64(len(m.Role)))
+ i--
+ dAtA[i] = 0x32
}
- if m.Type != 0 {
- dAtA[i] = 0x18
- i++
- i = encodeVarintMetric(dAtA, i, uint64(m.Type))
+ if m.Node != 0 {
+ i = encodeVarintMetric(dAtA, i, uint64(m.Node))
+ i--
+ dAtA[i] = 0x28
}
if len(m.Metric) > 0 {
- for _, msg := range m.Metric {
- dAtA[i] = 0x22
- i++
- i = encodeVarintMetric(dAtA, i, uint64(msg.Size()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
+ for iNdEx := len(m.Metric) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Metric[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintMetric(dAtA, i, uint64(size))
}
- i += n
+ i--
+ dAtA[i] = 0x22
}
}
- if m.Node != 0 {
- dAtA[i] = 0x28
- i++
- i = encodeVarintMetric(dAtA, i, uint64(m.Node))
+ if m.Type != 0 {
+ i = encodeVarintMetric(dAtA, i, uint64(m.Type))
+ i--
+ dAtA[i] = 0x18
}
- if len(m.Role) > 0 {
- dAtA[i] = 0x32
- i++
- i = encodeVarintMetric(dAtA, i, uint64(len(m.Role)))
- i += copy(dAtA[i:], m.Role)
+ if len(m.Help) > 0 {
+ i -= len(m.Help)
+ copy(dAtA[i:], m.Help)
+ i = encodeVarintMetric(dAtA, i, uint64(len(m.Help)))
+ i--
+ dAtA[i] = 0x12
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.Name) > 0 {
+ i -= len(m.Name)
+ copy(dAtA[i:], m.Name)
+ i = encodeVarintMetric(dAtA, i, uint64(len(m.Name)))
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func encodeVarintMetric(dAtA []byte, offset int, v uint64) int {
+ offset -= sovMetric(v)
+ base := offset
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
- return offset + 1
+ return base
}
func (m *LabelPair) Size() (n int) {
if m == nil {
@@ -1064,10 +1125,7 @@ func (m *LabelPair) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthMetric
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthMetric
}
if (iNdEx + skippy) > l {
@@ -1129,10 +1187,7 @@ func (m *Gauge) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthMetric
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthMetric
}
if (iNdEx + skippy) > l {
@@ -1194,10 +1249,7 @@ func (m *Counter) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthMetric
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthMetric
}
if (iNdEx + skippy) > l {
@@ -1278,10 +1330,7 @@ func (m *Sample) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthMetric
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthMetric
}
if (iNdEx + skippy) > l {
@@ -1366,10 +1415,7 @@ func (m *RawHist) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthMetric
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthMetric
}
if (iNdEx + skippy) > l {
@@ -1581,10 +1627,7 @@ func (m *Metric) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthMetric
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthMetric
}
if (iNdEx + skippy) > l {
@@ -1803,10 +1846,7 @@ func (m *MetricFamily) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthMetric
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthMetric
}
if (iNdEx + skippy) > l {
@@ -1825,6 +1865,7 @@ func (m *MetricFamily) Unmarshal(dAtA []byte) error {
func skipMetric(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
+ depth := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
@@ -1856,10 +1897,8 @@ func skipMetric(dAtA []byte) (n int, err error) {
break
}
}
- return iNdEx, nil
case 1:
iNdEx += 8
- return iNdEx, nil
case 2:
var length int
for shift := uint(0); ; shift += 7 {
@@ -1880,55 +1919,30 @@ func skipMetric(dAtA []byte) (n int, err error) {
return 0, ErrInvalidLengthMetric
}
iNdEx += length
- if iNdEx < 0 {
- return 0, ErrInvalidLengthMetric
- }
- return iNdEx, nil
case 3:
- for {
- var innerWire uint64
- var start int = iNdEx
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return 0, ErrIntOverflowMetric
- }
- if iNdEx >= l {
- return 0, io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- innerWire |= (uint64(b) & 0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- innerWireType := int(innerWire & 0x7)
- if innerWireType == 4 {
- break
- }
- next, err := skipMetric(dAtA[start:])
- if err != nil {
- return 0, err
- }
- iNdEx = start + next
- if iNdEx < 0 {
- return 0, ErrInvalidLengthMetric
- }
- }
- return iNdEx, nil
+ depth++
case 4:
- return iNdEx, nil
+ if depth == 0 {
+ return 0, ErrUnexpectedEndOfGroupMetric
+ }
+ depth--
case 5:
iNdEx += 4
- return iNdEx, nil
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
+ if iNdEx < 0 {
+ return 0, ErrInvalidLengthMetric
+ }
+ if depth == 0 {
+ return iNdEx, nil
+ }
}
- panic("unreachable")
+ return 0, io.ErrUnexpectedEOF
}
var (
- ErrInvalidLengthMetric = fmt.Errorf("proto: negative length found during unmarshaling")
- ErrIntOverflowMetric = fmt.Errorf("proto: integer overflow")
+ ErrInvalidLengthMetric = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowMetric = fmt.Errorf("proto: integer overflow")
+ ErrUnexpectedEndOfGroupMetric = fmt.Errorf("proto: unexpected end of group")
)
diff --git a/pkg/pb/plan/plan.pb.go b/pkg/pb/plan/plan.pb.go
index 8bc4027e79a38ef719ea97261d64eaed2346a562..ef9a32700173ac691e7e67f48b9e4a7191f586f8 100644
--- a/pkg/pb/plan/plan.pb.go
+++ b/pkg/pb/plan/plan.pb.go
@@ -23,7 +23,7 @@ var _ = math.Inf
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
type CompressType int32
@@ -830,7 +830,7 @@ func (m *Type) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Type.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -927,7 +927,7 @@ func (m *Const) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Const.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -953,37 +953,37 @@ type isConst_Value interface {
}
type Const_Ival struct {
- Ival int64 `protobuf:"varint,2,opt,name=ival,proto3,oneof"`
+ Ival int64 `protobuf:"varint,2,opt,name=ival,proto3,oneof" json:"ival,omitempty"`
}
type Const_Dval struct {
- Dval float64 `protobuf:"fixed64,3,opt,name=dval,proto3,oneof"`
+ Dval float64 `protobuf:"fixed64,3,opt,name=dval,proto3,oneof" json:"dval,omitempty"`
}
type Const_Sval struct {
- Sval string `protobuf:"bytes,4,opt,name=sval,proto3,oneof"`
+ Sval string `protobuf:"bytes,4,opt,name=sval,proto3,oneof" json:"sval,omitempty"`
}
type Const_Bval struct {
- Bval bool `protobuf:"varint,5,opt,name=bval,proto3,oneof"`
+ Bval bool `protobuf:"varint,5,opt,name=bval,proto3,oneof" json:"bval,omitempty"`
}
type Const_Uval struct {
- Uval uint64 `protobuf:"varint,6,opt,name=uval,proto3,oneof"`
+ Uval uint64 `protobuf:"varint,6,opt,name=uval,proto3,oneof" json:"uval,omitempty"`
}
type Const_Fval struct {
- Fval float32 `protobuf:"fixed32,7,opt,name=fval,proto3,oneof"`
+ Fval float32 `protobuf:"fixed32,7,opt,name=fval,proto3,oneof" json:"fval,omitempty"`
}
type Const_Dateval struct {
- Dateval int32 `protobuf:"varint,8,opt,name=dateval,proto3,oneof"`
+ Dateval int32 `protobuf:"varint,8,opt,name=dateval,proto3,oneof" json:"dateval,omitempty"`
}
type Const_Datetimeval struct {
- Datetimeval int64 `protobuf:"varint,9,opt,name=datetimeval,proto3,oneof"`
+ Datetimeval int64 `protobuf:"varint,9,opt,name=datetimeval,proto3,oneof" json:"datetimeval,omitempty"`
}
type Const_Decimal64Val struct {
- Decimal64Val int64 `protobuf:"varint,10,opt,name=decimal64val,proto3,oneof"`
+ Decimal64Val int64 `protobuf:"varint,10,opt,name=decimal64val,proto3,oneof" json:"decimal64val,omitempty"`
}
type Const_Decimal128Val struct {
- Decimal128Val *Decimal128 `protobuf:"bytes,11,opt,name=decimal128val,proto3,oneof"`
+ Decimal128Val *Decimal128 `protobuf:"bytes,11,opt,name=decimal128val,proto3,oneof" json:"decimal128val,omitempty"`
}
type Const_Timestampval struct {
- Timestampval int64 `protobuf:"varint,12,opt,name=timestampval,proto3,oneof"`
+ Timestampval int64 `protobuf:"varint,12,opt,name=timestampval,proto3,oneof" json:"timestampval,omitempty"`
}
func (*Const_Ival) isConst_Value() {}
@@ -1089,9 +1089,9 @@ func (m *Const) GetTimestampval() int64 {
return 0
}
-// XXX_OneofFuncs is for the internal use of the proto package.
-func (*Const) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
- return _Const_OneofMarshaler, _Const_OneofUnmarshaler, _Const_OneofSizer, []interface{}{
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*Const) XXX_OneofWrappers() []interface{} {
+ return []interface{}{
(*Const_Ival)(nil),
(*Const_Dval)(nil),
(*Const_Sval)(nil),
@@ -1106,189 +1106,6 @@ func (*Const) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error,
}
}
-func _Const_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
- m := msg.(*Const)
- // value
- switch x := m.Value.(type) {
- case *Const_Ival:
- _ = b.EncodeVarint(2<<3 | proto.WireVarint)
- _ = b.EncodeVarint(uint64(x.Ival))
- case *Const_Dval:
- _ = b.EncodeVarint(3<<3 | proto.WireFixed64)
- _ = b.EncodeFixed64(math.Float64bits(x.Dval))
- case *Const_Sval:
- _ = b.EncodeVarint(4<<3 | proto.WireBytes)
- _ = b.EncodeStringBytes(x.Sval)
- case *Const_Bval:
- t := uint64(0)
- if x.Bval {
- t = 1
- }
- _ = b.EncodeVarint(5<<3 | proto.WireVarint)
- _ = b.EncodeVarint(t)
- case *Const_Uval:
- _ = b.EncodeVarint(6<<3 | proto.WireVarint)
- _ = b.EncodeVarint(uint64(x.Uval))
- case *Const_Fval:
- _ = b.EncodeVarint(7<<3 | proto.WireFixed32)
- _ = b.EncodeFixed32(uint64(math.Float32bits(x.Fval)))
- case *Const_Dateval:
- _ = b.EncodeVarint(8<<3 | proto.WireVarint)
- _ = b.EncodeVarint(uint64(x.Dateval))
- case *Const_Datetimeval:
- _ = b.EncodeVarint(9<<3 | proto.WireVarint)
- _ = b.EncodeVarint(uint64(x.Datetimeval))
- case *Const_Decimal64Val:
- _ = b.EncodeVarint(10<<3 | proto.WireVarint)
- _ = b.EncodeVarint(uint64(x.Decimal64Val))
- case *Const_Decimal128Val:
- _ = b.EncodeVarint(11<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.Decimal128Val); err != nil {
- return err
- }
- case *Const_Timestampval:
- _ = b.EncodeVarint(12<<3 | proto.WireVarint)
- _ = b.EncodeVarint(uint64(x.Timestampval))
- case nil:
- default:
- return fmt.Errorf("Const.Value has unexpected type %T", x)
- }
- return nil
-}
-
-func _Const_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
- m := msg.(*Const)
- switch tag {
- case 2: // value.ival
- if wire != proto.WireVarint {
- return true, proto.ErrInternalBadWireType
- }
- x, err := b.DecodeVarint()
- m.Value = &Const_Ival{int64(x)}
- return true, err
- case 3: // value.dval
- if wire != proto.WireFixed64 {
- return true, proto.ErrInternalBadWireType
- }
- x, err := b.DecodeFixed64()
- m.Value = &Const_Dval{math.Float64frombits(x)}
- return true, err
- case 4: // value.sval
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- x, err := b.DecodeStringBytes()
- m.Value = &Const_Sval{x}
- return true, err
- case 5: // value.bval
- if wire != proto.WireVarint {
- return true, proto.ErrInternalBadWireType
- }
- x, err := b.DecodeVarint()
- m.Value = &Const_Bval{x != 0}
- return true, err
- case 6: // value.uval
- if wire != proto.WireVarint {
- return true, proto.ErrInternalBadWireType
- }
- x, err := b.DecodeVarint()
- m.Value = &Const_Uval{x}
- return true, err
- case 7: // value.fval
- if wire != proto.WireFixed32 {
- return true, proto.ErrInternalBadWireType
- }
- x, err := b.DecodeFixed32()
- m.Value = &Const_Fval{math.Float32frombits(uint32(x))}
- return true, err
- case 8: // value.dateval
- if wire != proto.WireVarint {
- return true, proto.ErrInternalBadWireType
- }
- x, err := b.DecodeVarint()
- m.Value = &Const_Dateval{int32(x)}
- return true, err
- case 9: // value.datetimeval
- if wire != proto.WireVarint {
- return true, proto.ErrInternalBadWireType
- }
- x, err := b.DecodeVarint()
- m.Value = &Const_Datetimeval{int64(x)}
- return true, err
- case 10: // value.decimal64val
- if wire != proto.WireVarint {
- return true, proto.ErrInternalBadWireType
- }
- x, err := b.DecodeVarint()
- m.Value = &Const_Decimal64Val{int64(x)}
- return true, err
- case 11: // value.decimal128val
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(Decimal128)
- err := b.DecodeMessage(msg)
- m.Value = &Const_Decimal128Val{msg}
- return true, err
- case 12: // value.timestampval
- if wire != proto.WireVarint {
- return true, proto.ErrInternalBadWireType
- }
- x, err := b.DecodeVarint()
- m.Value = &Const_Timestampval{int64(x)}
- return true, err
- default:
- return false, nil
- }
-}
-
-func _Const_OneofSizer(msg proto.Message) (n int) {
- m := msg.(*Const)
- // value
- switch x := m.Value.(type) {
- case *Const_Ival:
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(x.Ival))
- case *Const_Dval:
- n += 1 // tag and wire
- n += 8
- case *Const_Sval:
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(len(x.Sval)))
- n += len(x.Sval)
- case *Const_Bval:
- n += 1 // tag and wire
- n += 1
- case *Const_Uval:
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(x.Uval))
- case *Const_Fval:
- n += 1 // tag and wire
- n += 4
- case *Const_Dateval:
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(x.Dateval))
- case *Const_Datetimeval:
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(x.Datetimeval))
- case *Const_Decimal64Val:
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(x.Decimal64Val))
- case *Const_Decimal128Val:
- s := proto.Size(x.Decimal128Val)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *Const_Timestampval:
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(x.Timestampval))
- case nil:
- default:
- panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
- }
- return n
-}
-
// Bounded param for prepared statement. User fill on execution.
type ParamRef struct {
Pos int32 `protobuf:"varint,1,opt,name=pos,proto3" json:"pos,omitempty"`
@@ -1311,7 +1128,7 @@ func (m *ParamRef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ParamRef.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1359,7 +1176,7 @@ func (m *VarRef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_VarRef.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1409,7 +1226,7 @@ func (m *ColRef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ColRef.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1473,7 +1290,7 @@ func (m *CorrColRef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CorrColRef.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1535,7 +1352,7 @@ func (m *ExprList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ExprList.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1583,7 +1400,7 @@ func (m *TargetType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_TargetType.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1634,7 +1451,7 @@ func (m *SubqueryRef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_SubqueryRef.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1710,7 +1527,7 @@ func (m *ObjectRef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ObjectRef.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1807,7 +1624,7 @@ func (m *Function) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Function.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1872,7 +1689,7 @@ func (m *Expr) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Expr.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1898,31 +1715,31 @@ type isExpr_Expr interface {
}
type Expr_C struct {
- C *Const `protobuf:"bytes,2,opt,name=c,proto3,oneof"`
+ C *Const `protobuf:"bytes,2,opt,name=c,proto3,oneof" json:"c,omitempty"`
}
type Expr_P struct {
- P *ParamRef `protobuf:"bytes,3,opt,name=p,proto3,oneof"`
+ P *ParamRef `protobuf:"bytes,3,opt,name=p,proto3,oneof" json:"p,omitempty"`
}
type Expr_V struct {
- V *VarRef `protobuf:"bytes,4,opt,name=v,proto3,oneof"`
+ V *VarRef `protobuf:"bytes,4,opt,name=v,proto3,oneof" json:"v,omitempty"`
}
type Expr_Col struct {
- Col *ColRef `protobuf:"bytes,5,opt,name=col,proto3,oneof"`
+ Col *ColRef `protobuf:"bytes,5,opt,name=col,proto3,oneof" json:"col,omitempty"`
}
type Expr_F struct {
- F *Function `protobuf:"bytes,6,opt,name=f,proto3,oneof"`
+ F *Function `protobuf:"bytes,6,opt,name=f,proto3,oneof" json:"f,omitempty"`
}
type Expr_Sub struct {
- Sub *SubqueryRef `protobuf:"bytes,7,opt,name=sub,proto3,oneof"`
+ Sub *SubqueryRef `protobuf:"bytes,7,opt,name=sub,proto3,oneof" json:"sub,omitempty"`
}
type Expr_Corr struct {
- Corr *CorrColRef `protobuf:"bytes,8,opt,name=corr,proto3,oneof"`
+ Corr *CorrColRef `protobuf:"bytes,8,opt,name=corr,proto3,oneof" json:"corr,omitempty"`
}
type Expr_T struct {
- T *TargetType `protobuf:"bytes,9,opt,name=t,proto3,oneof"`
+ T *TargetType `protobuf:"bytes,9,opt,name=t,proto3,oneof" json:"t,omitempty"`
}
type Expr_List struct {
- List *ExprList `protobuf:"bytes,10,opt,name=list,proto3,oneof"`
+ List *ExprList `protobuf:"bytes,10,opt,name=list,proto3,oneof" json:"list,omitempty"`
}
func (*Expr_C) isExpr_Expr() {}
@@ -2012,9 +1829,9 @@ func (m *Expr) GetList() *ExprList {
return nil
}
-// XXX_OneofFuncs is for the internal use of the proto package.
-func (*Expr) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
- return _Expr_OneofMarshaler, _Expr_OneofUnmarshaler, _Expr_OneofSizer, []interface{}{
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*Expr) XXX_OneofWrappers() []interface{} {
+ return []interface{}{
(*Expr_C)(nil),
(*Expr_P)(nil),
(*Expr_V)(nil),
@@ -2027,198 +1844,6 @@ func (*Expr) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, f
}
}
-func _Expr_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
- m := msg.(*Expr)
- // expr
- switch x := m.Expr.(type) {
- case *Expr_C:
- _ = b.EncodeVarint(2<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.C); err != nil {
- return err
- }
- case *Expr_P:
- _ = b.EncodeVarint(3<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.P); err != nil {
- return err
- }
- case *Expr_V:
- _ = b.EncodeVarint(4<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.V); err != nil {
- return err
- }
- case *Expr_Col:
- _ = b.EncodeVarint(5<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.Col); err != nil {
- return err
- }
- case *Expr_F:
- _ = b.EncodeVarint(6<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.F); err != nil {
- return err
- }
- case *Expr_Sub:
- _ = b.EncodeVarint(7<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.Sub); err != nil {
- return err
- }
- case *Expr_Corr:
- _ = b.EncodeVarint(8<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.Corr); err != nil {
- return err
- }
- case *Expr_T:
- _ = b.EncodeVarint(9<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.T); err != nil {
- return err
- }
- case *Expr_List:
- _ = b.EncodeVarint(10<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.List); err != nil {
- return err
- }
- case nil:
- default:
- return fmt.Errorf("Expr.Expr has unexpected type %T", x)
- }
- return nil
-}
-
-func _Expr_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
- m := msg.(*Expr)
- switch tag {
- case 2: // expr.c
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(Const)
- err := b.DecodeMessage(msg)
- m.Expr = &Expr_C{msg}
- return true, err
- case 3: // expr.p
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(ParamRef)
- err := b.DecodeMessage(msg)
- m.Expr = &Expr_P{msg}
- return true, err
- case 4: // expr.v
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(VarRef)
- err := b.DecodeMessage(msg)
- m.Expr = &Expr_V{msg}
- return true, err
- case 5: // expr.col
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(ColRef)
- err := b.DecodeMessage(msg)
- m.Expr = &Expr_Col{msg}
- return true, err
- case 6: // expr.f
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(Function)
- err := b.DecodeMessage(msg)
- m.Expr = &Expr_F{msg}
- return true, err
- case 7: // expr.sub
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(SubqueryRef)
- err := b.DecodeMessage(msg)
- m.Expr = &Expr_Sub{msg}
- return true, err
- case 8: // expr.corr
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(CorrColRef)
- err := b.DecodeMessage(msg)
- m.Expr = &Expr_Corr{msg}
- return true, err
- case 9: // expr.t
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(TargetType)
- err := b.DecodeMessage(msg)
- m.Expr = &Expr_T{msg}
- return true, err
- case 10: // expr.list
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(ExprList)
- err := b.DecodeMessage(msg)
- m.Expr = &Expr_List{msg}
- return true, err
- default:
- return false, nil
- }
-}
-
-func _Expr_OneofSizer(msg proto.Message) (n int) {
- m := msg.(*Expr)
- // expr
- switch x := m.Expr.(type) {
- case *Expr_C:
- s := proto.Size(x.C)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *Expr_P:
- s := proto.Size(x.P)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *Expr_V:
- s := proto.Size(x.V)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *Expr_Col:
- s := proto.Size(x.Col)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *Expr_F:
- s := proto.Size(x.F)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *Expr_Sub:
- s := proto.Size(x.Sub)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *Expr_Corr:
- s := proto.Size(x.Corr)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *Expr_T:
- s := proto.Size(x.T)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *Expr_List:
- s := proto.Size(x.List)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case nil:
- default:
- panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
- }
- return n
-}
-
type DefaultExpr struct {
Exist bool `protobuf:"varint,1,opt,name=exist,proto3" json:"exist,omitempty"`
Value *ConstantValue `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
@@ -2242,7 +1867,7 @@ func (m *DefaultExpr) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_DefaultExpr.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -2316,7 +1941,7 @@ func (m *ConstantValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
return xxx_messageInfo_ConstantValue.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -2342,40 +1967,40 @@ type isConstantValue_ConstantValue interface {
}
type ConstantValue_UnknownV struct {
- UnknownV int32 `protobuf:"varint,1,opt,name=unknown_v,json=unknownV,proto3,oneof"`
+ UnknownV int32 `protobuf:"varint,1,opt,name=unknown_v,json=unknownV,proto3,oneof" json:"unknown_v,omitempty"`
}
type ConstantValue_Int64V struct {
- Int64V int64 `protobuf:"varint,2,opt,name=int64_v,json=int64V,proto3,oneof"`
+ Int64V int64 `protobuf:"varint,2,opt,name=int64_v,json=int64V,proto3,oneof" json:"int64_v,omitempty"`
}
type ConstantValue_Decimal64V struct {
- Decimal64V int64 `protobuf:"varint,3,opt,name=decimal64_v,json=decimal64V,proto3,oneof"`
+ Decimal64V int64 `protobuf:"varint,3,opt,name=decimal64_v,json=decimal64V,proto3,oneof" json:"decimal64_v,omitempty"`
}
type ConstantValue_Decimal128V struct {
- Decimal128V *Decimal128 `protobuf:"bytes,4,opt,name=decimal128_v,json=decimal128V,proto3,oneof"`
+ Decimal128V *Decimal128 `protobuf:"bytes,4,opt,name=decimal128_v,json=decimal128V,proto3,oneof" json:"decimal128_v,omitempty"`
}
type ConstantValue_Uint64V struct {
- Uint64V uint64 `protobuf:"varint,5,opt,name=uint64_v,json=uint64V,proto3,oneof"`
+ Uint64V uint64 `protobuf:"varint,5,opt,name=uint64_v,json=uint64V,proto3,oneof" json:"uint64_v,omitempty"`
}
type ConstantValue_Float32V struct {
- Float32V float32 `protobuf:"fixed32,6,opt,name=float32_v,json=float32V,proto3,oneof"`
+ Float32V float32 `protobuf:"fixed32,6,opt,name=float32_v,json=float32V,proto3,oneof" json:"float32_v,omitempty"`
}
type ConstantValue_Float64V struct {
- Float64V float64 `protobuf:"fixed64,7,opt,name=float64_v,json=float64V,proto3,oneof"`
+ Float64V float64 `protobuf:"fixed64,7,opt,name=float64_v,json=float64V,proto3,oneof" json:"float64_v,omitempty"`
}
type ConstantValue_DateV struct {
- DateV int32 `protobuf:"varint,8,opt,name=date_v,json=dateV,proto3,oneof"`
+ DateV int32 `protobuf:"varint,8,opt,name=date_v,json=dateV,proto3,oneof" json:"date_v,omitempty"`
}
type ConstantValue_DateTimeV struct {
- DateTimeV int64 `protobuf:"varint,9,opt,name=dateTime_v,json=dateTimeV,proto3,oneof"`
+ DateTimeV int64 `protobuf:"varint,9,opt,name=dateTime_v,json=dateTimeV,proto3,oneof" json:"dateTime_v,omitempty"`
}
type ConstantValue_TimeStampV struct {
- TimeStampV int64 `protobuf:"varint,10,opt,name=timeStamp_v,json=timeStampV,proto3,oneof"`
+ TimeStampV int64 `protobuf:"varint,10,opt,name=timeStamp_v,json=timeStampV,proto3,oneof" json:"timeStamp_v,omitempty"`
}
type ConstantValue_StringV struct {
- StringV string `protobuf:"bytes,11,opt,name=string_v,json=stringV,proto3,oneof"`
+ StringV string `protobuf:"bytes,11,opt,name=string_v,json=stringV,proto3,oneof" json:"string_v,omitempty"`
}
type ConstantValue_BoolV struct {
- BoolV bool `protobuf:"varint,12,opt,name=bool_v,json=boolV,proto3,oneof"`
+ BoolV bool `protobuf:"varint,12,opt,name=bool_v,json=boolV,proto3,oneof" json:"bool_v,omitempty"`
}
func (*ConstantValue_UnknownV) isConstantValue_ConstantValue() {}
@@ -2482,9 +2107,9 @@ func (m *ConstantValue) GetBoolV() bool {
return false
}
-// XXX_OneofFuncs is for the internal use of the proto package.
-func (*ConstantValue) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
- return _ConstantValue_OneofMarshaler, _ConstantValue_OneofUnmarshaler, _ConstantValue_OneofSizer, []interface{}{
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*ConstantValue) XXX_OneofWrappers() []interface{} {
+ return []interface{}{
(*ConstantValue_UnknownV)(nil),
(*ConstantValue_Int64V)(nil),
(*ConstantValue_Decimal64V)(nil),
@@ -2500,202 +2125,6 @@ func (*ConstantValue) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer)
}
}
-func _ConstantValue_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
- m := msg.(*ConstantValue)
- // constantValue
- switch x := m.ConstantValue.(type) {
- case *ConstantValue_UnknownV:
- _ = b.EncodeVarint(1<<3 | proto.WireVarint)
- _ = b.EncodeVarint(uint64(x.UnknownV))
- case *ConstantValue_Int64V:
- _ = b.EncodeVarint(2<<3 | proto.WireVarint)
- _ = b.EncodeVarint(uint64(x.Int64V))
- case *ConstantValue_Decimal64V:
- _ = b.EncodeVarint(3<<3 | proto.WireVarint)
- _ = b.EncodeVarint(uint64(x.Decimal64V))
- case *ConstantValue_Decimal128V:
- _ = b.EncodeVarint(4<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.Decimal128V); err != nil {
- return err
- }
- case *ConstantValue_Uint64V:
- _ = b.EncodeVarint(5<<3 | proto.WireVarint)
- _ = b.EncodeVarint(uint64(x.Uint64V))
- case *ConstantValue_Float32V:
- _ = b.EncodeVarint(6<<3 | proto.WireFixed32)
- _ = b.EncodeFixed32(uint64(math.Float32bits(x.Float32V)))
- case *ConstantValue_Float64V:
- _ = b.EncodeVarint(7<<3 | proto.WireFixed64)
- _ = b.EncodeFixed64(math.Float64bits(x.Float64V))
- case *ConstantValue_DateV:
- _ = b.EncodeVarint(8<<3 | proto.WireVarint)
- _ = b.EncodeVarint(uint64(x.DateV))
- case *ConstantValue_DateTimeV:
- _ = b.EncodeVarint(9<<3 | proto.WireVarint)
- _ = b.EncodeVarint(uint64(x.DateTimeV))
- case *ConstantValue_TimeStampV:
- _ = b.EncodeVarint(10<<3 | proto.WireVarint)
- _ = b.EncodeVarint(uint64(x.TimeStampV))
- case *ConstantValue_StringV:
- _ = b.EncodeVarint(11<<3 | proto.WireBytes)
- _ = b.EncodeStringBytes(x.StringV)
- case *ConstantValue_BoolV:
- t := uint64(0)
- if x.BoolV {
- t = 1
- }
- _ = b.EncodeVarint(12<<3 | proto.WireVarint)
- _ = b.EncodeVarint(t)
- case nil:
- default:
- return fmt.Errorf("ConstantValue.ConstantValue has unexpected type %T", x)
- }
- return nil
-}
-
-func _ConstantValue_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
- m := msg.(*ConstantValue)
- switch tag {
- case 1: // constantValue.unknown_v
- if wire != proto.WireVarint {
- return true, proto.ErrInternalBadWireType
- }
- x, err := b.DecodeVarint()
- m.ConstantValue = &ConstantValue_UnknownV{int32(x)}
- return true, err
- case 2: // constantValue.int64_v
- if wire != proto.WireVarint {
- return true, proto.ErrInternalBadWireType
- }
- x, err := b.DecodeVarint()
- m.ConstantValue = &ConstantValue_Int64V{int64(x)}
- return true, err
- case 3: // constantValue.decimal64_v
- if wire != proto.WireVarint {
- return true, proto.ErrInternalBadWireType
- }
- x, err := b.DecodeVarint()
- m.ConstantValue = &ConstantValue_Decimal64V{int64(x)}
- return true, err
- case 4: // constantValue.decimal128_v
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(Decimal128)
- err := b.DecodeMessage(msg)
- m.ConstantValue = &ConstantValue_Decimal128V{msg}
- return true, err
- case 5: // constantValue.uint64_v
- if wire != proto.WireVarint {
- return true, proto.ErrInternalBadWireType
- }
- x, err := b.DecodeVarint()
- m.ConstantValue = &ConstantValue_Uint64V{x}
- return true, err
- case 6: // constantValue.float32_v
- if wire != proto.WireFixed32 {
- return true, proto.ErrInternalBadWireType
- }
- x, err := b.DecodeFixed32()
- m.ConstantValue = &ConstantValue_Float32V{math.Float32frombits(uint32(x))}
- return true, err
- case 7: // constantValue.float64_v
- if wire != proto.WireFixed64 {
- return true, proto.ErrInternalBadWireType
- }
- x, err := b.DecodeFixed64()
- m.ConstantValue = &ConstantValue_Float64V{math.Float64frombits(x)}
- return true, err
- case 8: // constantValue.date_v
- if wire != proto.WireVarint {
- return true, proto.ErrInternalBadWireType
- }
- x, err := b.DecodeVarint()
- m.ConstantValue = &ConstantValue_DateV{int32(x)}
- return true, err
- case 9: // constantValue.dateTime_v
- if wire != proto.WireVarint {
- return true, proto.ErrInternalBadWireType
- }
- x, err := b.DecodeVarint()
- m.ConstantValue = &ConstantValue_DateTimeV{int64(x)}
- return true, err
- case 10: // constantValue.timeStamp_v
- if wire != proto.WireVarint {
- return true, proto.ErrInternalBadWireType
- }
- x, err := b.DecodeVarint()
- m.ConstantValue = &ConstantValue_TimeStampV{int64(x)}
- return true, err
- case 11: // constantValue.string_v
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- x, err := b.DecodeStringBytes()
- m.ConstantValue = &ConstantValue_StringV{x}
- return true, err
- case 12: // constantValue.bool_v
- if wire != proto.WireVarint {
- return true, proto.ErrInternalBadWireType
- }
- x, err := b.DecodeVarint()
- m.ConstantValue = &ConstantValue_BoolV{x != 0}
- return true, err
- default:
- return false, nil
- }
-}
-
-func _ConstantValue_OneofSizer(msg proto.Message) (n int) {
- m := msg.(*ConstantValue)
- // constantValue
- switch x := m.ConstantValue.(type) {
- case *ConstantValue_UnknownV:
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(x.UnknownV))
- case *ConstantValue_Int64V:
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(x.Int64V))
- case *ConstantValue_Decimal64V:
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(x.Decimal64V))
- case *ConstantValue_Decimal128V:
- s := proto.Size(x.Decimal128V)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *ConstantValue_Uint64V:
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(x.Uint64V))
- case *ConstantValue_Float32V:
- n += 1 // tag and wire
- n += 4
- case *ConstantValue_Float64V:
- n += 1 // tag and wire
- n += 8
- case *ConstantValue_DateV:
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(x.DateV))
- case *ConstantValue_DateTimeV:
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(x.DateTimeV))
- case *ConstantValue_TimeStampV:
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(x.TimeStampV))
- case *ConstantValue_StringV:
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(len(x.StringV)))
- n += len(x.StringV)
- case *ConstantValue_BoolV:
- n += 1 // tag and wire
- n += 1
- case nil:
- default:
- panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
- }
- return n
-}
-
type Decimal128 struct {
Lo int64 `protobuf:"varint,1,opt,name=Lo,proto3" json:"Lo,omitempty"`
Hi int64 `protobuf:"varint,2,opt,name=Hi,proto3" json:"Hi,omitempty"`
@@ -2718,7 +2147,7 @@ func (m *Decimal128) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Decimal128.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -2778,7 +2207,7 @@ func (m *ColDef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ColDef.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -2869,7 +2298,7 @@ func (m *IndexDef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_IndexDef.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -2930,7 +2359,7 @@ func (m *PrimaryKeyDef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
return xxx_messageInfo_PrimaryKeyDef.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -2978,7 +2407,7 @@ func (m *Property) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Property.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -3032,7 +2461,7 @@ func (m *PropertiesDef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
return xxx_messageInfo_PropertiesDef.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -3081,7 +2510,7 @@ func (m *TableDef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_TableDef.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -3146,7 +2575,7 @@ func (m *TableDef_DefType) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
return xxx_messageInfo_TableDef_DefType.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -3172,13 +2601,13 @@ type isTableDef_DefType_Def interface {
}
type TableDef_DefType_Pk struct {
- Pk *PrimaryKeyDef `protobuf:"bytes,1,opt,name=pk,proto3,oneof"`
+ Pk *PrimaryKeyDef `protobuf:"bytes,1,opt,name=pk,proto3,oneof" json:"pk,omitempty"`
}
type TableDef_DefType_Idx struct {
- Idx *IndexDef `protobuf:"bytes,2,opt,name=idx,proto3,oneof"`
+ Idx *IndexDef `protobuf:"bytes,2,opt,name=idx,proto3,oneof" json:"idx,omitempty"`
}
type TableDef_DefType_Properties struct {
- Properties *PropertiesDef `protobuf:"bytes,3,opt,name=properties,proto3,oneof"`
+ Properties *PropertiesDef `protobuf:"bytes,3,opt,name=properties,proto3,oneof" json:"properties,omitempty"`
}
func (*TableDef_DefType_Pk) isTableDef_DefType_Def() {}
@@ -3213,99 +2642,15 @@ func (m *TableDef_DefType) GetProperties() *PropertiesDef {
return nil
}
-// XXX_OneofFuncs is for the internal use of the proto package.
-func (*TableDef_DefType) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
- return _TableDef_DefType_OneofMarshaler, _TableDef_DefType_OneofUnmarshaler, _TableDef_DefType_OneofSizer, []interface{}{
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*TableDef_DefType) XXX_OneofWrappers() []interface{} {
+ return []interface{}{
(*TableDef_DefType_Pk)(nil),
(*TableDef_DefType_Idx)(nil),
(*TableDef_DefType_Properties)(nil),
}
}
-func _TableDef_DefType_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
- m := msg.(*TableDef_DefType)
- // def
- switch x := m.Def.(type) {
- case *TableDef_DefType_Pk:
- _ = b.EncodeVarint(1<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.Pk); err != nil {
- return err
- }
- case *TableDef_DefType_Idx:
- _ = b.EncodeVarint(2<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.Idx); err != nil {
- return err
- }
- case *TableDef_DefType_Properties:
- _ = b.EncodeVarint(3<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.Properties); err != nil {
- return err
- }
- case nil:
- default:
- return fmt.Errorf("TableDef_DefType.Def has unexpected type %T", x)
- }
- return nil
-}
-
-func _TableDef_DefType_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
- m := msg.(*TableDef_DefType)
- switch tag {
- case 1: // def.pk
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(PrimaryKeyDef)
- err := b.DecodeMessage(msg)
- m.Def = &TableDef_DefType_Pk{msg}
- return true, err
- case 2: // def.idx
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(IndexDef)
- err := b.DecodeMessage(msg)
- m.Def = &TableDef_DefType_Idx{msg}
- return true, err
- case 3: // def.properties
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(PropertiesDef)
- err := b.DecodeMessage(msg)
- m.Def = &TableDef_DefType_Properties{msg}
- return true, err
- default:
- return false, nil
- }
-}
-
-func _TableDef_DefType_OneofSizer(msg proto.Message) (n int) {
- m := msg.(*TableDef_DefType)
- // def
- switch x := m.Def.(type) {
- case *TableDef_DefType_Pk:
- s := proto.Size(x.Pk)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *TableDef_DefType_Idx:
- s := proto.Size(x.Idx)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *TableDef_DefType_Properties:
- s := proto.Size(x.Properties)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case nil:
- default:
- panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
- }
- return n
-}
-
type Cost struct {
Card float64 `protobuf:"fixed64,1,opt,name=card,proto3" json:"card,omitempty"`
Rowsize float64 `protobuf:"fixed64,2,opt,name=rowsize,proto3" json:"rowsize,omitempty"`
@@ -3331,7 +2676,7 @@ func (m *Cost) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Cost.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -3413,7 +2758,7 @@ func (m *ColData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ColData.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -3510,7 +2855,7 @@ func (m *RowsetData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_RowsetData.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -3566,7 +2911,7 @@ func (m *OrderBySpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_OrderBySpec.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -3630,7 +2975,7 @@ func (m *WindowSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_WindowSpec.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -3703,7 +3048,7 @@ func (m *UpdateInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UpdateInfo.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -3790,7 +3135,7 @@ func (m *AnalyzeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_AnalyzeInfo.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -3894,7 +3239,7 @@ func (m *Node) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Node.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -4098,7 +3443,7 @@ func (m *DeleteTableCtx) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro
return xxx_messageInfo_DeleteTableCtx.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -4176,7 +3521,7 @@ func (m *Query) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Query.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -4257,7 +3602,7 @@ func (m *TransationControl) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
return xxx_messageInfo_TransationControl.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -4283,13 +3628,13 @@ type isTransationControl_Action interface {
}
type TransationControl_Begin struct {
- Begin *TransationBegin `protobuf:"bytes,2,opt,name=begin,proto3,oneof"`
+ Begin *TransationBegin `protobuf:"bytes,2,opt,name=begin,proto3,oneof" json:"begin,omitempty"`
}
type TransationControl_Commit struct {
- Commit *TransationCommit `protobuf:"bytes,3,opt,name=commit,proto3,oneof"`
+ Commit *TransationCommit `protobuf:"bytes,3,opt,name=commit,proto3,oneof" json:"commit,omitempty"`
}
type TransationControl_Rollback struct {
- Rollback *TransationRollback `protobuf:"bytes,4,opt,name=rollback,proto3,oneof"`
+ Rollback *TransationRollback `protobuf:"bytes,4,opt,name=rollback,proto3,oneof" json:"rollback,omitempty"`
}
func (*TransationControl_Begin) isTransationControl_Action() {}
@@ -4331,99 +3676,15 @@ func (m *TransationControl) GetRollback() *TransationRollback {
return nil
}
-// XXX_OneofFuncs is for the internal use of the proto package.
-func (*TransationControl) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
- return _TransationControl_OneofMarshaler, _TransationControl_OneofUnmarshaler, _TransationControl_OneofSizer, []interface{}{
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*TransationControl) XXX_OneofWrappers() []interface{} {
+ return []interface{}{
(*TransationControl_Begin)(nil),
(*TransationControl_Commit)(nil),
(*TransationControl_Rollback)(nil),
}
}
-func _TransationControl_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
- m := msg.(*TransationControl)
- // action
- switch x := m.Action.(type) {
- case *TransationControl_Begin:
- _ = b.EncodeVarint(2<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.Begin); err != nil {
- return err
- }
- case *TransationControl_Commit:
- _ = b.EncodeVarint(3<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.Commit); err != nil {
- return err
- }
- case *TransationControl_Rollback:
- _ = b.EncodeVarint(4<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.Rollback); err != nil {
- return err
- }
- case nil:
- default:
- return fmt.Errorf("TransationControl.Action has unexpected type %T", x)
- }
- return nil
-}
-
-func _TransationControl_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
- m := msg.(*TransationControl)
- switch tag {
- case 2: // action.begin
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(TransationBegin)
- err := b.DecodeMessage(msg)
- m.Action = &TransationControl_Begin{msg}
- return true, err
- case 3: // action.commit
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(TransationCommit)
- err := b.DecodeMessage(msg)
- m.Action = &TransationControl_Commit{msg}
- return true, err
- case 4: // action.rollback
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(TransationRollback)
- err := b.DecodeMessage(msg)
- m.Action = &TransationControl_Rollback{msg}
- return true, err
- default:
- return false, nil
- }
-}
-
-func _TransationControl_OneofSizer(msg proto.Message) (n int) {
- m := msg.(*TransationControl)
- // action
- switch x := m.Action.(type) {
- case *TransationControl_Begin:
- s := proto.Size(x.Begin)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *TransationControl_Commit:
- s := proto.Size(x.Commit)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *TransationControl_Rollback:
- s := proto.Size(x.Rollback)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case nil:
- default:
- panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
- }
- return n
-}
-
type TransationBegin struct {
Mode TransationBegin_TransationMode `protobuf:"varint,1,opt,name=mode,proto3,enum=plan.TransationBegin_TransationMode" json:"mode,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
@@ -4445,7 +3706,7 @@ func (m *TransationBegin) XXX_Marshal(b []byte, deterministic bool) ([]byte, err
return xxx_messageInfo_TransationBegin.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -4492,7 +3753,7 @@ func (m *TransationCommit) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
return xxx_messageInfo_TransationCommit.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -4539,7 +3800,7 @@ func (m *TransationRollback) XXX_Marshal(b []byte, deterministic bool) ([]byte,
return xxx_messageInfo_TransationRollback.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -4591,7 +3852,7 @@ func (m *Plan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Plan.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -4617,16 +3878,16 @@ type isPlan_Plan interface {
}
type Plan_Query struct {
- Query *Query `protobuf:"bytes,1,opt,name=query,proto3,oneof"`
+ Query *Query `protobuf:"bytes,1,opt,name=query,proto3,oneof" json:"query,omitempty"`
}
type Plan_Tcl struct {
- Tcl *TransationControl `protobuf:"bytes,2,opt,name=tcl,proto3,oneof"`
+ Tcl *TransationControl `protobuf:"bytes,2,opt,name=tcl,proto3,oneof" json:"tcl,omitempty"`
}
type Plan_Ddl struct {
- Ddl *DataDefinition `protobuf:"bytes,3,opt,name=ddl,proto3,oneof"`
+ Ddl *DataDefinition `protobuf:"bytes,3,opt,name=ddl,proto3,oneof" json:"ddl,omitempty"`
}
type Plan_Dcl struct {
- Dcl *DataControl `protobuf:"bytes,4,opt,name=dcl,proto3,oneof"`
+ Dcl *DataControl `protobuf:"bytes,4,opt,name=dcl,proto3,oneof" json:"dcl,omitempty"`
}
func (*Plan_Query) isPlan_Plan() {}
@@ -4669,9 +3930,9 @@ func (m *Plan) GetDcl() *DataControl {
return nil
}
-// XXX_OneofFuncs is for the internal use of the proto package.
-func (*Plan) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
- return _Plan_OneofMarshaler, _Plan_OneofUnmarshaler, _Plan_OneofSizer, []interface{}{
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*Plan) XXX_OneofWrappers() []interface{} {
+ return []interface{}{
(*Plan_Query)(nil),
(*Plan_Tcl)(nil),
(*Plan_Ddl)(nil),
@@ -4679,108 +3940,6 @@ func (*Plan) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, f
}
}
-func _Plan_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
- m := msg.(*Plan)
- // plan
- switch x := m.Plan.(type) {
- case *Plan_Query:
- _ = b.EncodeVarint(1<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.Query); err != nil {
- return err
- }
- case *Plan_Tcl:
- _ = b.EncodeVarint(2<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.Tcl); err != nil {
- return err
- }
- case *Plan_Ddl:
- _ = b.EncodeVarint(3<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.Ddl); err != nil {
- return err
- }
- case *Plan_Dcl:
- _ = b.EncodeVarint(4<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.Dcl); err != nil {
- return err
- }
- case nil:
- default:
- return fmt.Errorf("Plan.Plan has unexpected type %T", x)
- }
- return nil
-}
-
-func _Plan_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
- m := msg.(*Plan)
- switch tag {
- case 1: // plan.query
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(Query)
- err := b.DecodeMessage(msg)
- m.Plan = &Plan_Query{msg}
- return true, err
- case 2: // plan.tcl
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(TransationControl)
- err := b.DecodeMessage(msg)
- m.Plan = &Plan_Tcl{msg}
- return true, err
- case 3: // plan.ddl
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(DataDefinition)
- err := b.DecodeMessage(msg)
- m.Plan = &Plan_Ddl{msg}
- return true, err
- case 4: // plan.dcl
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(DataControl)
- err := b.DecodeMessage(msg)
- m.Plan = &Plan_Dcl{msg}
- return true, err
- default:
- return false, nil
- }
-}
-
-func _Plan_OneofSizer(msg proto.Message) (n int) {
- m := msg.(*Plan)
- // plan
- switch x := m.Plan.(type) {
- case *Plan_Query:
- s := proto.Size(x.Query)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *Plan_Tcl:
- s := proto.Size(x.Tcl)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *Plan_Ddl:
- s := proto.Size(x.Ddl)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *Plan_Dcl:
- s := proto.Size(x.Dcl)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case nil:
- default:
- panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
- }
- return n
-}
-
type DataControl struct {
//DataDefinition type
DclType DataControl_DclType `protobuf:"varint,1,opt,name=dcl_type,json=dclType,proto3,enum=plan.DataControl_DclType" json:"dcl_type,omitempty"`
@@ -4809,7 +3968,7 @@ func (m *DataControl) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_DataControl.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -4835,16 +3994,16 @@ type isDataControl_Control interface {
}
type DataControl_SetVariables struct {
- SetVariables *SetVariables `protobuf:"bytes,2,opt,name=set_variables,json=setVariables,proto3,oneof"`
+ SetVariables *SetVariables `protobuf:"bytes,2,opt,name=set_variables,json=setVariables,proto3,oneof" json:"set_variables,omitempty"`
}
type DataControl_Prepare struct {
- Prepare *Prepare `protobuf:"bytes,3,opt,name=prepare,proto3,oneof"`
+ Prepare *Prepare `protobuf:"bytes,3,opt,name=prepare,proto3,oneof" json:"prepare,omitempty"`
}
type DataControl_Execute struct {
- Execute *Execute `protobuf:"bytes,4,opt,name=execute,proto3,oneof"`
+ Execute *Execute `protobuf:"bytes,4,opt,name=execute,proto3,oneof" json:"execute,omitempty"`
}
type DataControl_Deallocate struct {
- Deallocate *Deallocate `protobuf:"bytes,5,opt,name=deallocate,proto3,oneof"`
+ Deallocate *Deallocate `protobuf:"bytes,5,opt,name=deallocate,proto3,oneof" json:"deallocate,omitempty"`
}
func (*DataControl_SetVariables) isDataControl_Control() {}
@@ -4894,9 +4053,9 @@ func (m *DataControl) GetDeallocate() *Deallocate {
return nil
}
-// XXX_OneofFuncs is for the internal use of the proto package.
-func (*DataControl) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
- return _DataControl_OneofMarshaler, _DataControl_OneofUnmarshaler, _DataControl_OneofSizer, []interface{}{
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*DataControl) XXX_OneofWrappers() []interface{} {
+ return []interface{}{
(*DataControl_SetVariables)(nil),
(*DataControl_Prepare)(nil),
(*DataControl_Execute)(nil),
@@ -4904,108 +4063,6 @@ func (*DataControl) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) e
}
}
-func _DataControl_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
- m := msg.(*DataControl)
- // control
- switch x := m.Control.(type) {
- case *DataControl_SetVariables:
- _ = b.EncodeVarint(2<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.SetVariables); err != nil {
- return err
- }
- case *DataControl_Prepare:
- _ = b.EncodeVarint(3<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.Prepare); err != nil {
- return err
- }
- case *DataControl_Execute:
- _ = b.EncodeVarint(4<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.Execute); err != nil {
- return err
- }
- case *DataControl_Deallocate:
- _ = b.EncodeVarint(5<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.Deallocate); err != nil {
- return err
- }
- case nil:
- default:
- return fmt.Errorf("DataControl.Control has unexpected type %T", x)
- }
- return nil
-}
-
-func _DataControl_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
- m := msg.(*DataControl)
- switch tag {
- case 2: // control.set_variables
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(SetVariables)
- err := b.DecodeMessage(msg)
- m.Control = &DataControl_SetVariables{msg}
- return true, err
- case 3: // control.prepare
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(Prepare)
- err := b.DecodeMessage(msg)
- m.Control = &DataControl_Prepare{msg}
- return true, err
- case 4: // control.execute
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(Execute)
- err := b.DecodeMessage(msg)
- m.Control = &DataControl_Execute{msg}
- return true, err
- case 5: // control.deallocate
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(Deallocate)
- err := b.DecodeMessage(msg)
- m.Control = &DataControl_Deallocate{msg}
- return true, err
- default:
- return false, nil
- }
-}
-
-func _DataControl_OneofSizer(msg proto.Message) (n int) {
- m := msg.(*DataControl)
- // control
- switch x := m.Control.(type) {
- case *DataControl_SetVariables:
- s := proto.Size(x.SetVariables)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *DataControl_Prepare:
- s := proto.Size(x.Prepare)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *DataControl_Execute:
- s := proto.Size(x.Execute)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *DataControl_Deallocate:
- s := proto.Size(x.Deallocate)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case nil:
- default:
- panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
- }
- return n
-}
-
type DataDefinition struct {
//DataDefinition type
DdlType DataDefinition_DdlType `protobuf:"varint,1,opt,name=ddl_type,json=ddlType,proto3,enum=plan.DataDefinition_DdlType" json:"ddl_type,omitempty"`
@@ -5045,7 +4102,7 @@ func (m *DataDefinition) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro
return xxx_messageInfo_DataDefinition.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -5071,37 +4128,37 @@ type isDataDefinition_Definition interface {
}
type DataDefinition_CreateDatabase struct {
- CreateDatabase *CreateDatabase `protobuf:"bytes,3,opt,name=create_database,json=createDatabase,proto3,oneof"`
+ CreateDatabase *CreateDatabase `protobuf:"bytes,3,opt,name=create_database,json=createDatabase,proto3,oneof" json:"create_database,omitempty"`
}
type DataDefinition_AlterDatabase struct {
- AlterDatabase *AlterDatabase `protobuf:"bytes,4,opt,name=alter_database,json=alterDatabase,proto3,oneof"`
+ AlterDatabase *AlterDatabase `protobuf:"bytes,4,opt,name=alter_database,json=alterDatabase,proto3,oneof" json:"alter_database,omitempty"`
}
type DataDefinition_DropDatabase struct {
- DropDatabase *DropDatabase `protobuf:"bytes,5,opt,name=drop_database,json=dropDatabase,proto3,oneof"`
+ DropDatabase *DropDatabase `protobuf:"bytes,5,opt,name=drop_database,json=dropDatabase,proto3,oneof" json:"drop_database,omitempty"`
}
type DataDefinition_CreateTable struct {
- CreateTable *CreateTable `protobuf:"bytes,6,opt,name=create_table,json=createTable,proto3,oneof"`
+ CreateTable *CreateTable `protobuf:"bytes,6,opt,name=create_table,json=createTable,proto3,oneof" json:"create_table,omitempty"`
}
type DataDefinition_AlterTable struct {
- AlterTable *AlterTable `protobuf:"bytes,7,opt,name=alter_table,json=alterTable,proto3,oneof"`
+ AlterTable *AlterTable `protobuf:"bytes,7,opt,name=alter_table,json=alterTable,proto3,oneof" json:"alter_table,omitempty"`
}
type DataDefinition_DropTable struct {
- DropTable *DropTable `protobuf:"bytes,8,opt,name=drop_table,json=dropTable,proto3,oneof"`
+ DropTable *DropTable `protobuf:"bytes,8,opt,name=drop_table,json=dropTable,proto3,oneof" json:"drop_table,omitempty"`
}
type DataDefinition_CreateIndex struct {
- CreateIndex *CreateIndex `protobuf:"bytes,9,opt,name=create_index,json=createIndex,proto3,oneof"`
+ CreateIndex *CreateIndex `protobuf:"bytes,9,opt,name=create_index,json=createIndex,proto3,oneof" json:"create_index,omitempty"`
}
type DataDefinition_AlterIndex struct {
- AlterIndex *AlterIndex `protobuf:"bytes,10,opt,name=alter_index,json=alterIndex,proto3,oneof"`
+ AlterIndex *AlterIndex `protobuf:"bytes,10,opt,name=alter_index,json=alterIndex,proto3,oneof" json:"alter_index,omitempty"`
}
type DataDefinition_DropIndex struct {
- DropIndex *DropIndex `protobuf:"bytes,11,opt,name=drop_index,json=dropIndex,proto3,oneof"`
+ DropIndex *DropIndex `protobuf:"bytes,11,opt,name=drop_index,json=dropIndex,proto3,oneof" json:"drop_index,omitempty"`
}
type DataDefinition_TruncateTable struct {
- TruncateTable *TruncateTable `protobuf:"bytes,12,opt,name=truncate_table,json=truncateTable,proto3,oneof"`
+ TruncateTable *TruncateTable `protobuf:"bytes,12,opt,name=truncate_table,json=truncateTable,proto3,oneof" json:"truncate_table,omitempty"`
}
type DataDefinition_ShowVariables struct {
- ShowVariables *ShowVariables `protobuf:"bytes,13,opt,name=show_variables,json=showVariables,proto3,oneof"`
+ ShowVariables *ShowVariables `protobuf:"bytes,13,opt,name=show_variables,json=showVariables,proto3,oneof" json:"show_variables,omitempty"`
}
func (*DataDefinition_CreateDatabase) isDataDefinition_Definition() {}
@@ -5214,9 +4271,9 @@ func (m *DataDefinition) GetShowVariables() *ShowVariables {
return nil
}
-// XXX_OneofFuncs is for the internal use of the proto package.
-func (*DataDefinition) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
- return _DataDefinition_OneofMarshaler, _DataDefinition_OneofUnmarshaler, _DataDefinition_OneofSizer, []interface{}{
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*DataDefinition) XXX_OneofWrappers() []interface{} {
+ return []interface{}{
(*DataDefinition_CreateDatabase)(nil),
(*DataDefinition_AlterDatabase)(nil),
(*DataDefinition_DropDatabase)(nil),
@@ -5231,234 +4288,6 @@ func (*DataDefinition) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer
}
}
-func _DataDefinition_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
- m := msg.(*DataDefinition)
- // definition
- switch x := m.Definition.(type) {
- case *DataDefinition_CreateDatabase:
- _ = b.EncodeVarint(3<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.CreateDatabase); err != nil {
- return err
- }
- case *DataDefinition_AlterDatabase:
- _ = b.EncodeVarint(4<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.AlterDatabase); err != nil {
- return err
- }
- case *DataDefinition_DropDatabase:
- _ = b.EncodeVarint(5<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.DropDatabase); err != nil {
- return err
- }
- case *DataDefinition_CreateTable:
- _ = b.EncodeVarint(6<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.CreateTable); err != nil {
- return err
- }
- case *DataDefinition_AlterTable:
- _ = b.EncodeVarint(7<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.AlterTable); err != nil {
- return err
- }
- case *DataDefinition_DropTable:
- _ = b.EncodeVarint(8<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.DropTable); err != nil {
- return err
- }
- case *DataDefinition_CreateIndex:
- _ = b.EncodeVarint(9<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.CreateIndex); err != nil {
- return err
- }
- case *DataDefinition_AlterIndex:
- _ = b.EncodeVarint(10<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.AlterIndex); err != nil {
- return err
- }
- case *DataDefinition_DropIndex:
- _ = b.EncodeVarint(11<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.DropIndex); err != nil {
- return err
- }
- case *DataDefinition_TruncateTable:
- _ = b.EncodeVarint(12<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.TruncateTable); err != nil {
- return err
- }
- case *DataDefinition_ShowVariables:
- _ = b.EncodeVarint(13<<3 | proto.WireBytes)
- if err := b.EncodeMessage(x.ShowVariables); err != nil {
- return err
- }
- case nil:
- default:
- return fmt.Errorf("DataDefinition.Definition has unexpected type %T", x)
- }
- return nil
-}
-
-func _DataDefinition_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
- m := msg.(*DataDefinition)
- switch tag {
- case 3: // definition.create_database
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(CreateDatabase)
- err := b.DecodeMessage(msg)
- m.Definition = &DataDefinition_CreateDatabase{msg}
- return true, err
- case 4: // definition.alter_database
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(AlterDatabase)
- err := b.DecodeMessage(msg)
- m.Definition = &DataDefinition_AlterDatabase{msg}
- return true, err
- case 5: // definition.drop_database
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(DropDatabase)
- err := b.DecodeMessage(msg)
- m.Definition = &DataDefinition_DropDatabase{msg}
- return true, err
- case 6: // definition.create_table
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(CreateTable)
- err := b.DecodeMessage(msg)
- m.Definition = &DataDefinition_CreateTable{msg}
- return true, err
- case 7: // definition.alter_table
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(AlterTable)
- err := b.DecodeMessage(msg)
- m.Definition = &DataDefinition_AlterTable{msg}
- return true, err
- case 8: // definition.drop_table
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(DropTable)
- err := b.DecodeMessage(msg)
- m.Definition = &DataDefinition_DropTable{msg}
- return true, err
- case 9: // definition.create_index
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(CreateIndex)
- err := b.DecodeMessage(msg)
- m.Definition = &DataDefinition_CreateIndex{msg}
- return true, err
- case 10: // definition.alter_index
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(AlterIndex)
- err := b.DecodeMessage(msg)
- m.Definition = &DataDefinition_AlterIndex{msg}
- return true, err
- case 11: // definition.drop_index
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(DropIndex)
- err := b.DecodeMessage(msg)
- m.Definition = &DataDefinition_DropIndex{msg}
- return true, err
- case 12: // definition.truncate_table
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(TruncateTable)
- err := b.DecodeMessage(msg)
- m.Definition = &DataDefinition_TruncateTable{msg}
- return true, err
- case 13: // definition.show_variables
- if wire != proto.WireBytes {
- return true, proto.ErrInternalBadWireType
- }
- msg := new(ShowVariables)
- err := b.DecodeMessage(msg)
- m.Definition = &DataDefinition_ShowVariables{msg}
- return true, err
- default:
- return false, nil
- }
-}
-
-func _DataDefinition_OneofSizer(msg proto.Message) (n int) {
- m := msg.(*DataDefinition)
- // definition
- switch x := m.Definition.(type) {
- case *DataDefinition_CreateDatabase:
- s := proto.Size(x.CreateDatabase)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *DataDefinition_AlterDatabase:
- s := proto.Size(x.AlterDatabase)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *DataDefinition_DropDatabase:
- s := proto.Size(x.DropDatabase)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *DataDefinition_CreateTable:
- s := proto.Size(x.CreateTable)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *DataDefinition_AlterTable:
- s := proto.Size(x.AlterTable)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *DataDefinition_DropTable:
- s := proto.Size(x.DropTable)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *DataDefinition_CreateIndex:
- s := proto.Size(x.CreateIndex)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *DataDefinition_AlterIndex:
- s := proto.Size(x.AlterIndex)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *DataDefinition_DropIndex:
- s := proto.Size(x.DropIndex)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *DataDefinition_TruncateTable:
- s := proto.Size(x.TruncateTable)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case *DataDefinition_ShowVariables:
- s := proto.Size(x.ShowVariables)
- n += 1 // tag and wire
- n += proto.SizeVarint(uint64(s))
- n += s
- case nil:
- default:
- panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
- }
- return n
-}
-
type CreateDatabase struct {
IfNotExists bool `protobuf:"varint,1,opt,name=if_not_exists,json=ifNotExists,proto3" json:"if_not_exists,omitempty"`
Database string `protobuf:"bytes,2,opt,name=database,proto3" json:"database,omitempty"`
@@ -5481,7 +4310,7 @@ func (m *CreateDatabase) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro
return xxx_messageInfo_CreateDatabase.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -5536,7 +4365,7 @@ func (m *AlterDatabase) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
return xxx_messageInfo_AlterDatabase.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -5591,7 +4420,7 @@ func (m *DropDatabase) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_DropDatabase.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -5648,7 +4477,7 @@ func (m *CreateTable) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_CreateTable.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -5717,7 +4546,7 @@ func (m *AlterTable) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_AlterTable.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -5773,7 +4602,7 @@ func (m *DropTable) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DropTable.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -5835,7 +4664,7 @@ func (m *CreateIndex) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_CreateIndex.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -5889,7 +4718,7 @@ func (m *AlterIndex) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_AlterIndex.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -5937,7 +4766,7 @@ func (m *DropIndex) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DropIndex.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -5991,7 +4820,7 @@ func (m *TruncateTable) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
return xxx_messageInfo_TruncateTable.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -6039,7 +4868,7 @@ func (m *ShowVariables) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
return xxx_messageInfo_ShowVariables.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -6093,7 +4922,7 @@ func (m *SetVariables) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_SetVariables.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -6144,7 +4973,7 @@ func (m *SetVariablesItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
return xxx_messageInfo_SetVariablesItem.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -6220,7 +5049,7 @@ func (m *Prepare) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Prepare.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -6275,7 +5104,7 @@ func (m *Execute) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Execute.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -6329,7 +5158,7 @@ func (m *Deallocate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Deallocate.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -6733,7 +5562,7 @@ var fileDescriptor_2d655ab2f7683c23 = []byte{
func (m *Type) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -6741,55 +5570,61 @@ func (m *Type) Marshal() (dAtA []byte, err error) {
}
func (m *Type) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Type) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.Id != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Id))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if m.Nullable {
- dAtA[i] = 0x10
- i++
- if m.Nullable {
- dAtA[i] = 1
- } else {
- dAtA[i] = 0
- }
- i++
+ if m.Scale != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.Scale))
+ i--
+ dAtA[i] = 0x30
}
- if m.Width != 0 {
- dAtA[i] = 0x18
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Width))
+ if m.Size != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.Size))
+ i--
+ dAtA[i] = 0x28
}
if m.Precision != 0 {
- dAtA[i] = 0x20
- i++
i = encodeVarintPlan(dAtA, i, uint64(m.Precision))
+ i--
+ dAtA[i] = 0x20
}
- if m.Size != 0 {
- dAtA[i] = 0x28
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Size))
+ if m.Width != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.Width))
+ i--
+ dAtA[i] = 0x18
}
- if m.Scale != 0 {
- dAtA[i] = 0x30
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Scale))
+ if m.Nullable {
+ i--
+ if m.Nullable {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ i--
+ dAtA[i] = 0x10
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.Id != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.Id))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Const) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -6797,129 +5632,195 @@ func (m *Const) Marshal() (dAtA []byte, err error) {
}
func (m *Const) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Const) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
+ if m.Value != nil {
+ {
+ size := m.Value.ProtoSize()
+ i -= size
+ if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil {
+ return 0, err
+ }
+ }
+ }
if m.Isnull {
- dAtA[i] = 0x8
- i++
+ i--
if m.Isnull {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
- i++
- }
- if m.Value != nil {
- nn1, err1 := m.Value.MarshalTo(dAtA[i:])
- if err1 != nil {
- return 0, err1
- }
- i += nn1
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Const_Ival) MarshalTo(dAtA []byte) (int, error) {
- i := 0
- dAtA[i] = 0x10
- i++
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Const_Ival) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
i = encodeVarintPlan(dAtA, i, uint64(m.Ival))
- return i, nil
+ i--
+ dAtA[i] = 0x10
+ return len(dAtA) - i, nil
}
func (m *Const_Dval) MarshalTo(dAtA []byte) (int, error) {
- i := 0
- dAtA[i] = 0x19
- i++
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Const_Dval) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ i -= 8
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Dval))))
- i += 8
- return i, nil
+ i--
+ dAtA[i] = 0x19
+ return len(dAtA) - i, nil
}
func (m *Const_Sval) MarshalTo(dAtA []byte) (int, error) {
- i := 0
- dAtA[i] = 0x22
- i++
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Const_Sval) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ i -= len(m.Sval)
+ copy(dAtA[i:], m.Sval)
i = encodeVarintPlan(dAtA, i, uint64(len(m.Sval)))
- i += copy(dAtA[i:], m.Sval)
- return i, nil
+ i--
+ dAtA[i] = 0x22
+ return len(dAtA) - i, nil
}
func (m *Const_Bval) MarshalTo(dAtA []byte) (int, error) {
- i := 0
- dAtA[i] = 0x28
- i++
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Const_Bval) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ i--
if m.Bval {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
- i++
- return i, nil
+ i--
+ dAtA[i] = 0x28
+ return len(dAtA) - i, nil
}
func (m *Const_Uval) MarshalTo(dAtA []byte) (int, error) {
- i := 0
- dAtA[i] = 0x30
- i++
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Const_Uval) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
i = encodeVarintPlan(dAtA, i, uint64(m.Uval))
- return i, nil
+ i--
+ dAtA[i] = 0x30
+ return len(dAtA) - i, nil
}
func (m *Const_Fval) MarshalTo(dAtA []byte) (int, error) {
- i := 0
- dAtA[i] = 0x3d
- i++
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Const_Fval) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ i -= 4
encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Fval))))
- i += 4
- return i, nil
+ i--
+ dAtA[i] = 0x3d
+ return len(dAtA) - i, nil
}
func (m *Const_Dateval) MarshalTo(dAtA []byte) (int, error) {
- i := 0
- dAtA[i] = 0x40
- i++
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Const_Dateval) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
i = encodeVarintPlan(dAtA, i, uint64(m.Dateval))
- return i, nil
+ i--
+ dAtA[i] = 0x40
+ return len(dAtA) - i, nil
}
func (m *Const_Datetimeval) MarshalTo(dAtA []byte) (int, error) {
- i := 0
- dAtA[i] = 0x48
- i++
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Const_Datetimeval) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
i = encodeVarintPlan(dAtA, i, uint64(m.Datetimeval))
- return i, nil
+ i--
+ dAtA[i] = 0x48
+ return len(dAtA) - i, nil
}
func (m *Const_Decimal64Val) MarshalTo(dAtA []byte) (int, error) {
- i := 0
- dAtA[i] = 0x50
- i++
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Const_Decimal64Val) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
i = encodeVarintPlan(dAtA, i, uint64(m.Decimal64Val))
- return i, nil
+ i--
+ dAtA[i] = 0x50
+ return len(dAtA) - i, nil
}
func (m *Const_Decimal128Val) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Const_Decimal128Val) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.Decimal128Val != nil {
- dAtA[i] = 0x5a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Decimal128Val.ProtoSize()))
- n2, err2 := m.Decimal128Val.MarshalTo(dAtA[i:])
- if err2 != nil {
- return 0, err2
+ {
+ size, err := m.Decimal128Val.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n2
+ i--
+ dAtA[i] = 0x5a
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Const_Timestampval) MarshalTo(dAtA []byte) (int, error) {
- i := 0
- dAtA[i] = 0x60
- i++
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Const_Timestampval) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
i = encodeVarintPlan(dAtA, i, uint64(m.Timestampval))
- return i, nil
+ i--
+ dAtA[i] = 0x60
+ return len(dAtA) - i, nil
}
func (m *ParamRef) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -6927,25 +5828,31 @@ func (m *ParamRef) Marshal() (dAtA []byte, err error) {
}
func (m *ParamRef) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ParamRef) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if m.Pos != 0 {
- dAtA[i] = 0x8
- i++
i = encodeVarintPlan(dAtA, i, uint64(m.Pos))
+ i--
+ dAtA[i] = 0x8
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
- }
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *VarRef) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -6953,26 +5860,33 @@ func (m *VarRef) Marshal() (dAtA []byte, err error) {
}
func (m *VarRef) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *VarRef) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if len(m.Name) > 0 {
- dAtA[i] = 0xa
- i++
+ i -= len(m.Name)
+ copy(dAtA[i:], m.Name)
i = encodeVarintPlan(dAtA, i, uint64(len(m.Name)))
- i += copy(dAtA[i:], m.Name)
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *ColRef) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -6980,36 +5894,43 @@ func (m *ColRef) Marshal() (dAtA []byte, err error) {
}
func (m *ColRef) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ColRef) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.RelPos != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.RelPos))
- }
- if m.ColPos != 0 {
- dAtA[i] = 0x10
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.ColPos))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Name) > 0 {
- dAtA[i] = 0x1a
- i++
+ i -= len(m.Name)
+ copy(dAtA[i:], m.Name)
i = encodeVarintPlan(dAtA, i, uint64(len(m.Name)))
- i += copy(dAtA[i:], m.Name)
+ i--
+ dAtA[i] = 0x1a
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.ColPos != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.ColPos))
+ i--
+ dAtA[i] = 0x10
+ }
+ if m.RelPos != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.RelPos))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *CorrColRef) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -7017,35 +5938,41 @@ func (m *CorrColRef) Marshal() (dAtA []byte, err error) {
}
func (m *CorrColRef) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CorrColRef) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.RelPos != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.RelPos))
- }
- if m.ColPos != 0 {
- dAtA[i] = 0x10
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.ColPos))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if m.Depth != 0 {
- dAtA[i] = 0x18
- i++
i = encodeVarintPlan(dAtA, i, uint64(m.Depth))
+ i--
+ dAtA[i] = 0x18
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.ColPos != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.ColPos))
+ i--
+ dAtA[i] = 0x10
}
- return i, nil
-}
-
+ if m.RelPos != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.RelPos))
+ i--
+ dAtA[i] = 0x8
+ }
+ return len(dAtA) - i, nil
+}
+
func (m *ExprList) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -7053,32 +5980,40 @@ func (m *ExprList) Marshal() (dAtA []byte, err error) {
}
func (m *ExprList) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ExprList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if len(m.List) > 0 {
- for _, msg := range m.List {
- dAtA[i] = 0xa
- i++
- i = encodeVarintPlan(dAtA, i, uint64(msg.ProtoSize()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
+ for iNdEx := len(m.List) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.List[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n
+ i--
+ dAtA[i] = 0xa
}
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
- }
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TargetType) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -7086,30 +6021,38 @@ func (m *TargetType) Marshal() (dAtA []byte, err error) {
}
func (m *TargetType) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TargetType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if m.Typ != nil {
- dAtA[i] = 0xa
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Typ.ProtoSize()))
- n3, err3 := m.Typ.MarshalTo(dAtA[i:])
- if err3 != nil {
- return 0, err3
+ {
+ size, err := m.Typ.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n3
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *SubqueryRef) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -7117,46 +6060,55 @@ func (m *SubqueryRef) Marshal() (dAtA []byte, err error) {
}
func (m *SubqueryRef) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *SubqueryRef) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.Typ != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Typ))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if m.NodeId != 0 {
- dAtA[i] = 0x10
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.NodeId))
+ if m.Child != nil {
+ {
+ size, err := m.Child.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x22
}
if len(m.Op) > 0 {
- dAtA[i] = 0x1a
- i++
+ i -= len(m.Op)
+ copy(dAtA[i:], m.Op)
i = encodeVarintPlan(dAtA, i, uint64(len(m.Op)))
- i += copy(dAtA[i:], m.Op)
+ i--
+ dAtA[i] = 0x1a
}
- if m.Child != nil {
- dAtA[i] = 0x22
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Child.ProtoSize()))
- n4, err4 := m.Child.MarshalTo(dAtA[i:])
- if err4 != nil {
- return 0, err4
- }
- i += n4
+ if m.NodeId != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.NodeId))
+ i--
+ dAtA[i] = 0x10
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.Typ != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.Typ))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *ObjectRef) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -7164,64 +6116,74 @@ func (m *ObjectRef) Marshal() (dAtA []byte, err error) {
}
func (m *ObjectRef) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ObjectRef) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.Server != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Server))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if m.Db != 0 {
- dAtA[i] = 0x10
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Db))
+ if len(m.ObjName) > 0 {
+ i -= len(m.ObjName)
+ copy(dAtA[i:], m.ObjName)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.ObjName)))
+ i--
+ dAtA[i] = 0x42
}
- if m.Schema != 0 {
- dAtA[i] = 0x18
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Schema))
+ if len(m.SchemaName) > 0 {
+ i -= len(m.SchemaName)
+ copy(dAtA[i:], m.SchemaName)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.SchemaName)))
+ i--
+ dAtA[i] = 0x3a
}
- if m.Obj != 0 {
- dAtA[i] = 0x20
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Obj))
+ if len(m.DbName) > 0 {
+ i -= len(m.DbName)
+ copy(dAtA[i:], m.DbName)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.DbName)))
+ i--
+ dAtA[i] = 0x32
}
if len(m.ServerName) > 0 {
- dAtA[i] = 0x2a
- i++
+ i -= len(m.ServerName)
+ copy(dAtA[i:], m.ServerName)
i = encodeVarintPlan(dAtA, i, uint64(len(m.ServerName)))
- i += copy(dAtA[i:], m.ServerName)
+ i--
+ dAtA[i] = 0x2a
}
- if len(m.DbName) > 0 {
- dAtA[i] = 0x32
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.DbName)))
- i += copy(dAtA[i:], m.DbName)
+ if m.Obj != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.Obj))
+ i--
+ dAtA[i] = 0x20
}
- if len(m.SchemaName) > 0 {
- dAtA[i] = 0x3a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.SchemaName)))
- i += copy(dAtA[i:], m.SchemaName)
+ if m.Schema != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.Schema))
+ i--
+ dAtA[i] = 0x18
}
- if len(m.ObjName) > 0 {
- dAtA[i] = 0x42
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.ObjName)))
- i += copy(dAtA[i:], m.ObjName)
+ if m.Db != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.Db))
+ i--
+ dAtA[i] = 0x10
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.Server != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.Server))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Function) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -7229,42 +6191,52 @@ func (m *Function) Marshal() (dAtA []byte, err error) {
}
func (m *Function) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Function) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.Func != nil {
- dAtA[i] = 0xa
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Func.ProtoSize()))
- n5, err5 := m.Func.MarshalTo(dAtA[i:])
- if err5 != nil {
- return 0, err5
- }
- i += n5
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Args) > 0 {
- for _, msg := range m.Args {
+ for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Args[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
+ }
+ i--
dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(msg.ProtoSize()))
- n, err := msg.MarshalTo(dAtA[i:])
+ }
+ }
+ if m.Func != nil {
+ {
+ size, err := m.Func.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
- i += n
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
+ i--
+ dAtA[i] = 0xa
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
- }
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Expr) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -7272,163 +6244,236 @@ func (m *Expr) Marshal() (dAtA []byte, err error) {
}
func (m *Expr) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Expr) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.Typ != nil {
- dAtA[i] = 0xa
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Typ.ProtoSize()))
- n6, err6 := m.Typ.MarshalTo(dAtA[i:])
- if err6 != nil {
- return 0, err6
- }
- i += n6
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if m.Expr != nil {
- nn7, err7 := m.Expr.MarshalTo(dAtA[i:])
- if err7 != nil {
- return 0, err7
+ {
+ size := m.Expr.ProtoSize()
+ i -= size
+ if _, err := m.Expr.MarshalTo(dAtA[i:]); err != nil {
+ return 0, err
+ }
}
- i += nn7
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.Typ != nil {
+ {
+ size, err := m.Typ.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Expr_C) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Expr_C) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.C != nil {
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.C.ProtoSize()))
- n8, err8 := m.C.MarshalTo(dAtA[i:])
- if err8 != nil {
- return 0, err8
+ {
+ size, err := m.C.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n8
+ i--
+ dAtA[i] = 0x12
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Expr_P) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Expr_P) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.P != nil {
- dAtA[i] = 0x1a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.P.ProtoSize()))
- n9, err9 := m.P.MarshalTo(dAtA[i:])
- if err9 != nil {
- return 0, err9
+ {
+ size, err := m.P.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n9
+ i--
+ dAtA[i] = 0x1a
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Expr_V) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Expr_V) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.V != nil {
- dAtA[i] = 0x22
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.V.ProtoSize()))
- n10, err10 := m.V.MarshalTo(dAtA[i:])
- if err10 != nil {
- return 0, err10
+ {
+ size, err := m.V.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n10
+ i--
+ dAtA[i] = 0x22
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Expr_Col) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Expr_Col) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.Col != nil {
- dAtA[i] = 0x2a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Col.ProtoSize()))
- n11, err11 := m.Col.MarshalTo(dAtA[i:])
- if err11 != nil {
- return 0, err11
+ {
+ size, err := m.Col.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n11
+ i--
+ dAtA[i] = 0x2a
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Expr_F) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Expr_F) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.F != nil {
- dAtA[i] = 0x32
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.F.ProtoSize()))
- n12, err12 := m.F.MarshalTo(dAtA[i:])
- if err12 != nil {
- return 0, err12
+ {
+ size, err := m.F.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n12
+ i--
+ dAtA[i] = 0x32
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Expr_Sub) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Expr_Sub) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.Sub != nil {
- dAtA[i] = 0x3a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Sub.ProtoSize()))
- n13, err13 := m.Sub.MarshalTo(dAtA[i:])
- if err13 != nil {
- return 0, err13
+ {
+ size, err := m.Sub.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n13
+ i--
+ dAtA[i] = 0x3a
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Expr_Corr) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Expr_Corr) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.Corr != nil {
- dAtA[i] = 0x42
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Corr.ProtoSize()))
- n14, err14 := m.Corr.MarshalTo(dAtA[i:])
- if err14 != nil {
- return 0, err14
+ {
+ size, err := m.Corr.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n14
+ i--
+ dAtA[i] = 0x42
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Expr_T) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Expr_T) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.T != nil {
- dAtA[i] = 0x4a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.T.ProtoSize()))
- n15, err15 := m.T.MarshalTo(dAtA[i:])
- if err15 != nil {
- return 0, err15
+ {
+ size, err := m.T.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n15
+ i--
+ dAtA[i] = 0x4a
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Expr_List) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Expr_List) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.List != nil {
- dAtA[i] = 0x52
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.List.ProtoSize()))
- n16, err16 := m.List.MarshalTo(dAtA[i:])
- if err16 != nil {
- return 0, err16
+ {
+ size, err := m.List.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n16
+ i--
+ dAtA[i] = 0x52
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DefaultExpr) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -7436,50 +6481,58 @@ func (m *DefaultExpr) Marshal() (dAtA []byte, err error) {
}
func (m *DefaultExpr) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DefaultExpr) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.Exist {
- dAtA[i] = 0x8
- i++
- if m.Exist {
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
+ if m.IsNull {
+ i--
+ if m.IsNull {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
- i++
+ i--
+ dAtA[i] = 0x18
}
if m.Value != nil {
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Value.ProtoSize()))
- n17, err17 := m.Value.MarshalTo(dAtA[i:])
- if err17 != nil {
- return 0, err17
+ {
+ size, err := m.Value.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n17
+ i--
+ dAtA[i] = 0x12
}
- if m.IsNull {
- dAtA[i] = 0x18
- i++
- if m.IsNull {
+ if m.Exist {
+ i--
+ if m.Exist {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
- i++
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *ConstantValue) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -7487,126 +6540,197 @@ func (m *ConstantValue) Marshal() (dAtA []byte, err error) {
}
func (m *ConstantValue) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ConstantValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if m.ConstantValue != nil {
- nn18, err18 := m.ConstantValue.MarshalTo(dAtA[i:])
- if err18 != nil {
- return 0, err18
+ {
+ size := m.ConstantValue.ProtoSize()
+ i -= size
+ if _, err := m.ConstantValue.MarshalTo(dAtA[i:]); err != nil {
+ return 0, err
+ }
}
- i += nn18
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *ConstantValue_UnknownV) MarshalTo(dAtA []byte) (int, error) {
- i := 0
- dAtA[i] = 0x8
- i++
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ConstantValue_UnknownV) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
i = encodeVarintPlan(dAtA, i, uint64(m.UnknownV))
- return i, nil
+ i--
+ dAtA[i] = 0x8
+ return len(dAtA) - i, nil
}
func (m *ConstantValue_Int64V) MarshalTo(dAtA []byte) (int, error) {
- i := 0
- dAtA[i] = 0x10
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Int64V))
- return i, nil
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *ConstantValue_Decimal64V) MarshalTo(dAtA []byte) (int, error) {
- i := 0
- dAtA[i] = 0x18
- i++
+
+func (m *ConstantValue_Int64V) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ i = encodeVarintPlan(dAtA, i, uint64(m.Int64V))
+ i--
+ dAtA[i] = 0x10
+ return len(dAtA) - i, nil
+}
+func (m *ConstantValue_Decimal64V) MarshalTo(dAtA []byte) (int, error) {
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ConstantValue_Decimal64V) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
i = encodeVarintPlan(dAtA, i, uint64(m.Decimal64V))
- return i, nil
+ i--
+ dAtA[i] = 0x18
+ return len(dAtA) - i, nil
}
func (m *ConstantValue_Decimal128V) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ConstantValue_Decimal128V) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.Decimal128V != nil {
- dAtA[i] = 0x22
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Decimal128V.ProtoSize()))
- n19, err19 := m.Decimal128V.MarshalTo(dAtA[i:])
- if err19 != nil {
- return 0, err19
+ {
+ size, err := m.Decimal128V.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n19
+ i--
+ dAtA[i] = 0x22
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *ConstantValue_Uint64V) MarshalTo(dAtA []byte) (int, error) {
- i := 0
- dAtA[i] = 0x28
- i++
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ConstantValue_Uint64V) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
i = encodeVarintPlan(dAtA, i, uint64(m.Uint64V))
- return i, nil
+ i--
+ dAtA[i] = 0x28
+ return len(dAtA) - i, nil
}
func (m *ConstantValue_Float32V) MarshalTo(dAtA []byte) (int, error) {
- i := 0
- dAtA[i] = 0x35
- i++
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ConstantValue_Float32V) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ i -= 4
encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Float32V))))
- i += 4
- return i, nil
+ i--
+ dAtA[i] = 0x35
+ return len(dAtA) - i, nil
}
func (m *ConstantValue_Float64V) MarshalTo(dAtA []byte) (int, error) {
- i := 0
- dAtA[i] = 0x39
- i++
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ConstantValue_Float64V) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ i -= 8
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Float64V))))
- i += 8
- return i, nil
+ i--
+ dAtA[i] = 0x39
+ return len(dAtA) - i, nil
}
func (m *ConstantValue_DateV) MarshalTo(dAtA []byte) (int, error) {
- i := 0
- dAtA[i] = 0x40
- i++
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ConstantValue_DateV) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
i = encodeVarintPlan(dAtA, i, uint64(m.DateV))
- return i, nil
+ i--
+ dAtA[i] = 0x40
+ return len(dAtA) - i, nil
}
func (m *ConstantValue_DateTimeV) MarshalTo(dAtA []byte) (int, error) {
- i := 0
- dAtA[i] = 0x48
- i++
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ConstantValue_DateTimeV) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
i = encodeVarintPlan(dAtA, i, uint64(m.DateTimeV))
- return i, nil
+ i--
+ dAtA[i] = 0x48
+ return len(dAtA) - i, nil
}
func (m *ConstantValue_TimeStampV) MarshalTo(dAtA []byte) (int, error) {
- i := 0
- dAtA[i] = 0x50
- i++
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ConstantValue_TimeStampV) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
i = encodeVarintPlan(dAtA, i, uint64(m.TimeStampV))
- return i, nil
+ i--
+ dAtA[i] = 0x50
+ return len(dAtA) - i, nil
}
func (m *ConstantValue_StringV) MarshalTo(dAtA []byte) (int, error) {
- i := 0
- dAtA[i] = 0x5a
- i++
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ConstantValue_StringV) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ i -= len(m.StringV)
+ copy(dAtA[i:], m.StringV)
i = encodeVarintPlan(dAtA, i, uint64(len(m.StringV)))
- i += copy(dAtA[i:], m.StringV)
- return i, nil
+ i--
+ dAtA[i] = 0x5a
+ return len(dAtA) - i, nil
}
func (m *ConstantValue_BoolV) MarshalTo(dAtA []byte) (int, error) {
- i := 0
- dAtA[i] = 0x60
- i++
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ConstantValue_BoolV) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ i--
if m.BoolV {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
- i++
- return i, nil
+ i--
+ dAtA[i] = 0x60
+ return len(dAtA) - i, nil
}
func (m *Decimal128) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -7614,30 +6738,36 @@ func (m *Decimal128) Marshal() (dAtA []byte, err error) {
}
func (m *Decimal128) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Decimal128) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.Lo != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Lo))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if m.Hi != 0 {
- dAtA[i] = 0x10
- i++
i = encodeVarintPlan(dAtA, i, uint64(m.Hi))
+ i--
+ dAtA[i] = 0x10
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.Lo != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.Lo))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *ColDef) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -7645,72 +6775,84 @@ func (m *ColDef) Marshal() (dAtA []byte, err error) {
}
func (m *ColDef) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ColDef) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.Name) > 0 {
- dAtA[i] = 0xa
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.Name)))
- i += copy(dAtA[i:], m.Name)
- }
- if m.Alg != 0 {
- dAtA[i] = 0x10
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Alg))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if m.Typ != nil {
- dAtA[i] = 0x1a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Typ.ProtoSize()))
- n20, err20 := m.Typ.MarshalTo(dAtA[i:])
- if err20 != nil {
- return 0, err20
- }
- i += n20
+ if len(m.Comment) > 0 {
+ i -= len(m.Comment)
+ copy(dAtA[i:], m.Comment)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.Comment)))
+ i--
+ dAtA[i] = 0x3a
}
- if m.Default != nil {
- dAtA[i] = 0x22
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Default.ProtoSize()))
- n21, err21 := m.Default.MarshalTo(dAtA[i:])
- if err21 != nil {
- return 0, err21
- }
- i += n21
+ if m.Pkidx != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.Pkidx))
+ i--
+ dAtA[i] = 0x30
}
if m.Primary {
- dAtA[i] = 0x28
- i++
+ i--
if m.Primary {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
- i++
+ i--
+ dAtA[i] = 0x28
+ }
+ if m.Default != nil {
+ {
+ size, err := m.Default.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x22
}
- if m.Pkidx != 0 {
- dAtA[i] = 0x30
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Pkidx))
+ if m.Typ != nil {
+ {
+ size, err := m.Typ.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x1a
}
- if len(m.Comment) > 0 {
- dAtA[i] = 0x3a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.Comment)))
- i += copy(dAtA[i:], m.Comment)
+ if m.Alg != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.Alg))
+ i--
+ dAtA[i] = 0x10
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.Name) > 0 {
+ i -= len(m.Name)
+ copy(dAtA[i:], m.Name)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.Name)))
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *IndexDef) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -7718,46 +6860,47 @@ func (m *IndexDef) Marshal() (dAtA []byte, err error) {
}
func (m *IndexDef) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *IndexDef) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.Typ != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Typ))
- }
- if len(m.Name) > 0 {
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.Name)))
- i += copy(dAtA[i:], m.Name)
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.ColNames) > 0 {
- for _, s := range m.ColNames {
+ for iNdEx := len(m.ColNames) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(m.ColNames[iNdEx])
+ copy(dAtA[i:], m.ColNames[iNdEx])
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.ColNames[iNdEx])))
+ i--
dAtA[i] = 0x1a
- i++
- l = len(s)
- for l >= 1<<7 {
- dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
- l >>= 7
- i++
- }
- dAtA[i] = uint8(l)
- i++
- i += copy(dAtA[i:], s)
}
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.Name) > 0 {
+ i -= len(m.Name)
+ copy(dAtA[i:], m.Name)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.Name)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if m.Typ != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.Typ))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *PrimaryKeyDef) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -7765,35 +6908,35 @@ func (m *PrimaryKeyDef) Marshal() (dAtA []byte, err error) {
}
func (m *PrimaryKeyDef) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *PrimaryKeyDef) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if len(m.Names) > 0 {
- for _, s := range m.Names {
+ for iNdEx := len(m.Names) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(m.Names[iNdEx])
+ copy(dAtA[i:], m.Names[iNdEx])
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.Names[iNdEx])))
+ i--
dAtA[i] = 0xa
- i++
- l = len(s)
- for l >= 1<<7 {
- dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
- l >>= 7
- i++
- }
- dAtA[i] = uint8(l)
- i++
- i += copy(dAtA[i:], s)
}
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
- }
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Property) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -7801,32 +6944,40 @@ func (m *Property) Marshal() (dAtA []byte, err error) {
}
func (m *Property) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Property) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.Key) > 0 {
- dAtA[i] = 0xa
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.Key)))
- i += copy(dAtA[i:], m.Key)
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Value) > 0 {
- dAtA[i] = 0x12
- i++
+ i -= len(m.Value)
+ copy(dAtA[i:], m.Value)
i = encodeVarintPlan(dAtA, i, uint64(len(m.Value)))
- i += copy(dAtA[i:], m.Value)
+ i--
+ dAtA[i] = 0x12
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.Key) > 0 {
+ i -= len(m.Key)
+ copy(dAtA[i:], m.Key)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.Key)))
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *PropertiesDef) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -7834,32 +6985,40 @@ func (m *PropertiesDef) Marshal() (dAtA []byte, err error) {
}
func (m *PropertiesDef) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *PropertiesDef) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if len(m.Properties) > 0 {
- for _, msg := range m.Properties {
- dAtA[i] = 0xa
- i++
- i = encodeVarintPlan(dAtA, i, uint64(msg.ProtoSize()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
+ for iNdEx := len(m.Properties) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Properties[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n
+ i--
+ dAtA[i] = 0xa
}
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
- }
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TableDef) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -7867,50 +7026,61 @@ func (m *TableDef) Marshal() (dAtA []byte, err error) {
}
func (m *TableDef) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TableDef) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.Name) > 0 {
- dAtA[i] = 0xa
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.Name)))
- i += copy(dAtA[i:], m.Name)
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if len(m.Cols) > 0 {
- for _, msg := range m.Cols {
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(msg.ProtoSize()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
+ if len(m.Defs) > 0 {
+ for iNdEx := len(m.Defs) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Defs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n
+ i--
+ dAtA[i] = 0x1a
}
}
- if len(m.Defs) > 0 {
- for _, msg := range m.Defs {
- dAtA[i] = 0x1a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(msg.ProtoSize()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
+ if len(m.Cols) > 0 {
+ for iNdEx := len(m.Cols) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Cols[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n
+ i--
+ dAtA[i] = 0x12
}
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.Name) > 0 {
+ i -= len(m.Name)
+ copy(dAtA[i:], m.Name)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.Name)))
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TableDef_DefType) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -7918,69 +7088,98 @@ func (m *TableDef_DefType) Marshal() (dAtA []byte, err error) {
}
func (m *TableDef_DefType) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TableDef_DefType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if m.Def != nil {
- nn22, err22 := m.Def.MarshalTo(dAtA[i:])
- if err22 != nil {
- return 0, err22
+ {
+ size := m.Def.ProtoSize()
+ i -= size
+ if _, err := m.Def.MarshalTo(dAtA[i:]); err != nil {
+ return 0, err
+ }
}
- i += nn22
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TableDef_DefType_Pk) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TableDef_DefType_Pk) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.Pk != nil {
- dAtA[i] = 0xa
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Pk.ProtoSize()))
- n23, err23 := m.Pk.MarshalTo(dAtA[i:])
- if err23 != nil {
- return 0, err23
+ {
+ size, err := m.Pk.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n23
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TableDef_DefType_Idx) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TableDef_DefType_Idx) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.Idx != nil {
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Idx.ProtoSize()))
- n24, err24 := m.Idx.MarshalTo(dAtA[i:])
- if err24 != nil {
- return 0, err24
+ {
+ size, err := m.Idx.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n24
+ i--
+ dAtA[i] = 0x12
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TableDef_DefType_Properties) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TableDef_DefType_Properties) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.Properties != nil {
- dAtA[i] = 0x1a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Properties.ProtoSize()))
- n25, err25 := m.Properties.MarshalTo(dAtA[i:])
- if err25 != nil {
- return 0, err25
+ {
+ size, err := m.Properties.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n25
+ i--
+ dAtA[i] = 0x1a
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Cost) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -7988,50 +7187,56 @@ func (m *Cost) Marshal() (dAtA []byte, err error) {
}
func (m *Cost) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Cost) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.Card != 0 {
- dAtA[i] = 0x9
- i++
- encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Card))))
- i += 8
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if m.Rowsize != 0 {
- dAtA[i] = 0x11
- i++
- encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Rowsize))))
- i += 8
- }
- if m.Ndv != 0 {
- dAtA[i] = 0x19
- i++
- encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Ndv))))
- i += 8
+ if m.Total != 0 {
+ i -= 8
+ encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Total))))
+ i--
+ dAtA[i] = 0x29
}
if m.Start != 0 {
- dAtA[i] = 0x21
- i++
+ i -= 8
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Start))))
- i += 8
+ i--
+ dAtA[i] = 0x21
}
- if m.Total != 0 {
- dAtA[i] = 0x29
- i++
- encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Total))))
- i += 8
+ if m.Ndv != 0 {
+ i -= 8
+ encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Ndv))))
+ i--
+ dAtA[i] = 0x19
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.Rowsize != 0 {
+ i -= 8
+ encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Rowsize))))
+ i--
+ dAtA[i] = 0x11
}
- return i, nil
+ if m.Card != 0 {
+ i -= 8
+ encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Card))))
+ i--
+ dAtA[i] = 0x9
+ }
+ return len(dAtA) - i, nil
}
func (m *ColData) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -8039,32 +7244,66 @@ func (m *ColData) Marshal() (dAtA []byte, err error) {
}
func (m *ColData) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ColData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.RowCount != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.RowCount))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if m.NullCount != 0 {
- dAtA[i] = 0x10
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.NullCount))
+ if len(m.S) > 0 {
+ for iNdEx := len(m.S) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(m.S[iNdEx])
+ copy(dAtA[i:], m.S[iNdEx])
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.S[iNdEx])))
+ i--
+ dAtA[i] = 0x42
+ }
}
- if len(m.Nulls) > 0 {
- dAtA[i] = 0x1a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.Nulls)))
- for _, b := range m.Nulls {
- if b {
- dAtA[i] = 1
- } else {
- dAtA[i] = 0
+ if len(m.F64) > 0 {
+ for iNdEx := len(m.F64) - 1; iNdEx >= 0; iNdEx-- {
+ f22 := math.Float64bits(float64(m.F64[iNdEx]))
+ i -= 8
+ encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f22))
+ }
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.F64)*8))
+ i--
+ dAtA[i] = 0x3a
+ }
+ if len(m.F32) > 0 {
+ for iNdEx := len(m.F32) - 1; iNdEx >= 0; iNdEx-- {
+ f23 := math.Float32bits(float32(m.F32[iNdEx]))
+ i -= 4
+ encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f23))
+ }
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.F32)*4))
+ i--
+ dAtA[i] = 0x32
+ }
+ if len(m.I64) > 0 {
+ dAtA25 := make([]byte, len(m.I64)*10)
+ var j24 int
+ for _, num1 := range m.I64 {
+ num := uint64(num1)
+ for num >= 1<<7 {
+ dAtA25[j24] = uint8(uint64(num)&0x7f | 0x80)
+ num >>= 7
+ j24++
}
- i++
+ dAtA25[j24] = uint8(num)
+ j24++
}
+ i -= j24
+ copy(dAtA[i:], dAtA25[:j24])
+ i = encodeVarintPlan(dAtA, i, uint64(j24))
+ i--
+ dAtA[i] = 0x2a
}
if len(m.I32) > 0 {
dAtA27 := make([]byte, len(m.I32)*10)
@@ -8079,74 +7318,42 @@ func (m *ColData) MarshalTo(dAtA []byte) (int, error) {
dAtA27[j26] = uint8(num)
j26++
}
- dAtA[i] = 0x22
- i++
+ i -= j26
+ copy(dAtA[i:], dAtA27[:j26])
i = encodeVarintPlan(dAtA, i, uint64(j26))
- i += copy(dAtA[i:], dAtA27[:j26])
+ i--
+ dAtA[i] = 0x22
}
- if len(m.I64) > 0 {
- dAtA29 := make([]byte, len(m.I64)*10)
- var j28 int
- for _, num1 := range m.I64 {
- num := uint64(num1)
- for num >= 1<<7 {
- dAtA29[j28] = uint8(uint64(num)&0x7f | 0x80)
- num >>= 7
- j28++
+ if len(m.Nulls) > 0 {
+ for iNdEx := len(m.Nulls) - 1; iNdEx >= 0; iNdEx-- {
+ i--
+ if m.Nulls[iNdEx] {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
}
- dAtA29[j28] = uint8(num)
- j28++
- }
- dAtA[i] = 0x2a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(j28))
- i += copy(dAtA[i:], dAtA29[:j28])
- }
- if len(m.F32) > 0 {
- dAtA[i] = 0x32
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.F32)*4))
- for _, num := range m.F32 {
- f30 := math.Float32bits(float32(num))
- encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f30))
- i += 4
- }
- }
- if len(m.F64) > 0 {
- dAtA[i] = 0x3a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.F64)*8))
- for _, num := range m.F64 {
- f31 := math.Float64bits(float64(num))
- encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f31))
- i += 8
}
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.Nulls)))
+ i--
+ dAtA[i] = 0x1a
}
- if len(m.S) > 0 {
- for _, s := range m.S {
- dAtA[i] = 0x42
- i++
- l = len(s)
- for l >= 1<<7 {
- dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
- l >>= 7
- i++
- }
- dAtA[i] = uint8(l)
- i++
- i += copy(dAtA[i:], s)
- }
+ if m.NullCount != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.NullCount))
+ i--
+ dAtA[i] = 0x10
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.RowCount != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.RowCount))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *RowsetData) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -8154,42 +7361,52 @@ func (m *RowsetData) Marshal() (dAtA []byte, err error) {
}
func (m *RowsetData) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *RowsetData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.Schema != nil {
- dAtA[i] = 0xa
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Schema.ProtoSize()))
- n32, err32 := m.Schema.MarshalTo(dAtA[i:])
- if err32 != nil {
- return 0, err32
- }
- i += n32
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Cols) > 0 {
- for _, msg := range m.Cols {
+ for iNdEx := len(m.Cols) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Cols[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
+ }
+ i--
dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(msg.ProtoSize()))
- n, err := msg.MarshalTo(dAtA[i:])
+ }
+ }
+ if m.Schema != nil {
+ {
+ size, err := m.Schema.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
- i += n
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
+ i--
+ dAtA[i] = 0xa
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
- }
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *OrderBySpec) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -8197,41 +7414,50 @@ func (m *OrderBySpec) Marshal() (dAtA []byte, err error) {
}
func (m *OrderBySpec) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *OrderBySpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.Expr != nil {
- dAtA[i] = 0xa
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Expr.ProtoSize()))
- n33, err33 := m.Expr.MarshalTo(dAtA[i:])
- if err33 != nil {
- return 0, err33
- }
- i += n33
- }
- if len(m.Collation) > 0 {
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.Collation)))
- i += copy(dAtA[i:], m.Collation)
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if m.Flag != 0 {
- dAtA[i] = 0x18
- i++
i = encodeVarintPlan(dAtA, i, uint64(m.Flag))
+ i--
+ dAtA[i] = 0x18
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.Collation) > 0 {
+ i -= len(m.Collation)
+ copy(dAtA[i:], m.Collation)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.Collation)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if m.Expr != nil {
+ {
+ size, err := m.Expr.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *WindowSpec) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -8239,54 +7465,64 @@ func (m *WindowSpec) Marshal() (dAtA []byte, err error) {
}
func (m *WindowSpec) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *WindowSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.PartitionBy) > 0 {
- for _, msg := range m.PartitionBy {
- dAtA[i] = 0xa
- i++
- i = encodeVarintPlan(dAtA, i, uint64(msg.ProtoSize()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
- }
- i += n
- }
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if len(m.OrderBy) > 0 {
- for _, msg := range m.OrderBy {
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(msg.ProtoSize()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
- }
- i += n
- }
+ if m.Lag != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.Lag))
+ i--
+ dAtA[i] = 0x20
}
if m.Lead != 0 {
- dAtA[i] = 0x18
- i++
i = encodeVarintPlan(dAtA, i, uint64(m.Lead))
+ i--
+ dAtA[i] = 0x18
}
- if m.Lag != 0 {
- dAtA[i] = 0x20
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Lag))
+ if len(m.OrderBy) > 0 {
+ for iNdEx := len(m.OrderBy) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.OrderBy[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x12
+ }
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.PartitionBy) > 0 {
+ for iNdEx := len(m.PartitionBy) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.PartitionBy[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0xa
+ }
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *UpdateInfo) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -8294,82 +7530,72 @@ func (m *UpdateInfo) Marshal() (dAtA []byte, err error) {
}
func (m *UpdateInfo) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *UpdateInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.PriKey) > 0 {
- dAtA[i] = 0xa
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.PriKey)))
- i += copy(dAtA[i:], m.PriKey)
- }
- if m.PriKeyIdx != 0 {
- dAtA[i] = 0x10
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.PriKeyIdx))
- }
- if len(m.HideKey) > 0 {
- dAtA[i] = 0x1a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.HideKey)))
- i += copy(dAtA[i:], m.HideKey)
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if len(m.UpdateAttrs) > 0 {
- for _, s := range m.UpdateAttrs {
- dAtA[i] = 0x22
- i++
- l = len(s)
- for l >= 1<<7 {
- dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
- l >>= 7
- i++
- }
- dAtA[i] = uint8(l)
- i++
- i += copy(dAtA[i:], s)
+ if len(m.AttrOrders) > 0 {
+ for iNdEx := len(m.AttrOrders) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(m.AttrOrders[iNdEx])
+ copy(dAtA[i:], m.AttrOrders[iNdEx])
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.AttrOrders[iNdEx])))
+ i--
+ dAtA[i] = 0x32
}
}
if len(m.OtherAttrs) > 0 {
- for _, s := range m.OtherAttrs {
+ for iNdEx := len(m.OtherAttrs) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(m.OtherAttrs[iNdEx])
+ copy(dAtA[i:], m.OtherAttrs[iNdEx])
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.OtherAttrs[iNdEx])))
+ i--
dAtA[i] = 0x2a
- i++
- l = len(s)
- for l >= 1<<7 {
- dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
- l >>= 7
- i++
- }
- dAtA[i] = uint8(l)
- i++
- i += copy(dAtA[i:], s)
}
}
- if len(m.AttrOrders) > 0 {
- for _, s := range m.AttrOrders {
- dAtA[i] = 0x32
- i++
- l = len(s)
- for l >= 1<<7 {
- dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
- l >>= 7
- i++
- }
- dAtA[i] = uint8(l)
- i++
- i += copy(dAtA[i:], s)
+ if len(m.UpdateAttrs) > 0 {
+ for iNdEx := len(m.UpdateAttrs) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(m.UpdateAttrs[iNdEx])
+ copy(dAtA[i:], m.UpdateAttrs[iNdEx])
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.UpdateAttrs[iNdEx])))
+ i--
+ dAtA[i] = 0x22
}
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.HideKey) > 0 {
+ i -= len(m.HideKey)
+ copy(dAtA[i:], m.HideKey)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.HideKey)))
+ i--
+ dAtA[i] = 0x1a
}
- return i, nil
+ if m.PriKeyIdx != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.PriKeyIdx))
+ i--
+ dAtA[i] = 0x10
+ }
+ if len(m.PriKey) > 0 {
+ i -= len(m.PriKey)
+ copy(dAtA[i:], m.PriKey)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.PriKey)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
}
func (m *AnalyzeInfo) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -8377,50 +7603,56 @@ func (m *AnalyzeInfo) Marshal() (dAtA []byte, err error) {
}
func (m *AnalyzeInfo) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AnalyzeInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.InputRows != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.InputRows))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if m.OutputRows != 0 {
- dAtA[i] = 0x10
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.OutputRows))
+ if m.MemorySize != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.MemorySize))
+ i--
+ dAtA[i] = 0x30
}
- if m.InputSize != 0 {
- dAtA[i] = 0x18
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.InputSize))
+ if m.TimeConsumed != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.TimeConsumed))
+ i--
+ dAtA[i] = 0x28
}
if m.OutputSize != 0 {
- dAtA[i] = 0x20
- i++
i = encodeVarintPlan(dAtA, i, uint64(m.OutputSize))
+ i--
+ dAtA[i] = 0x20
}
- if m.TimeConsumed != 0 {
- dAtA[i] = 0x28
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.TimeConsumed))
+ if m.InputSize != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.InputSize))
+ i--
+ dAtA[i] = 0x18
}
- if m.MemorySize != 0 {
- dAtA[i] = 0x30
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.MemorySize))
+ if m.OutputRows != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.OutputRows))
+ i--
+ dAtA[i] = 0x10
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.InputRows != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.InputRows))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Node) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -8428,279 +7660,322 @@ func (m *Node) Marshal() (dAtA []byte, err error) {
}
func (m *Node) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Node) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.NodeType != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.NodeType))
- }
- if m.NodeId != 0 {
- dAtA[i] = 0x10
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.NodeId))
- }
- if m.Cost != nil {
- dAtA[i] = 0x1a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Cost.ProtoSize()))
- n34, err34 := m.Cost.MarshalTo(dAtA[i:])
- if err34 != nil {
- return 0, err34
- }
- i += n34
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if len(m.ProjectList) > 0 {
- for _, msg := range m.ProjectList {
- dAtA[i] = 0x22
- i++
- i = encodeVarintPlan(dAtA, i, uint64(msg.ProtoSize()))
- n, err := msg.MarshalTo(dAtA[i:])
+ if m.AnalyzeInfo != nil {
+ {
+ size, err := m.AnalyzeInfo.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
- i += n
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0xba
}
- if len(m.Children) > 0 {
- dAtA36 := make([]byte, len(m.Children)*10)
- var j35 int
- for _, num1 := range m.Children {
+ if len(m.BindingTags) > 0 {
+ dAtA32 := make([]byte, len(m.BindingTags)*10)
+ var j31 int
+ for _, num1 := range m.BindingTags {
num := uint64(num1)
for num >= 1<<7 {
- dAtA36[j35] = uint8(uint64(num)&0x7f | 0x80)
+ dAtA32[j31] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
- j35++
+ j31++
}
- dAtA36[j35] = uint8(num)
- j35++
+ dAtA32[j31] = uint8(num)
+ j31++
}
- dAtA[i] = 0x2a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(j35))
- i += copy(dAtA[i:], dAtA36[:j35])
+ i -= j31
+ copy(dAtA[i:], dAtA32[:j31])
+ i = encodeVarintPlan(dAtA, i, uint64(j31))
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0xb2
}
- if m.JoinType != 0 {
- dAtA[i] = 0x30
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.JoinType))
+ if len(m.DeleteTablesCtx) > 0 {
+ for iNdEx := len(m.DeleteTablesCtx) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.DeleteTablesCtx[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0xaa
+ }
}
- if len(m.OnList) > 0 {
- for _, msg := range m.OnList {
- dAtA[i] = 0x3a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(msg.ProtoSize()))
- n, err := msg.MarshalTo(dAtA[i:])
+ if len(m.ExtraOptions) > 0 {
+ i -= len(m.ExtraOptions)
+ copy(dAtA[i:], m.ExtraOptions)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.ExtraOptions)))
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0xa2
+ }
+ if m.RowsetData != nil {
+ {
+ size, err := m.RowsetData.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
- i += n
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0x9a
}
- if len(m.FilterList) > 0 {
- for _, msg := range m.FilterList {
- dAtA[i] = 0x42
- i++
- i = encodeVarintPlan(dAtA, i, uint64(msg.ProtoSize()))
- n, err := msg.MarshalTo(dAtA[i:])
+ if m.ObjRef != nil {
+ {
+ size, err := m.ObjRef.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
- i += n
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0x92
}
- if len(m.GroupBy) > 0 {
- for _, msg := range m.GroupBy {
- dAtA[i] = 0x4a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(msg.ProtoSize()))
- n, err := msg.MarshalTo(dAtA[i:])
+ if m.TableDef != nil {
+ {
+ size, err := m.TableDef.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
- i += n
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0x8a
}
- if len(m.GroupingSet) > 0 {
- for _, msg := range m.GroupingSet {
- dAtA[i] = 0x52
- i++
- i = encodeVarintPlan(dAtA, i, uint64(msg.ProtoSize()))
- n, err := msg.MarshalTo(dAtA[i:])
+ if m.Offset != nil {
+ {
+ size, err := m.Offset.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
- i += n
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0x82
}
- if len(m.AggList) > 0 {
- for _, msg := range m.AggList {
- dAtA[i] = 0x5a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(msg.ProtoSize()))
- n, err := msg.MarshalTo(dAtA[i:])
+ if m.Limit != nil {
+ {
+ size, err := m.Limit.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
- i += n
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
+ i--
+ dAtA[i] = 0x7a
}
- if len(m.OrderBy) > 0 {
- for _, msg := range m.OrderBy {
- dAtA[i] = 0x62
- i++
- i = encodeVarintPlan(dAtA, i, uint64(msg.ProtoSize()))
- n, err := msg.MarshalTo(dAtA[i:])
+ if m.WinSpec != nil {
+ {
+ size, err := m.WinSpec.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
- i += n
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
+ i--
+ dAtA[i] = 0x72
}
if m.UpdateInfo != nil {
- dAtA[i] = 0x6a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.UpdateInfo.ProtoSize()))
- n37, err37 := m.UpdateInfo.MarshalTo(dAtA[i:])
- if err37 != nil {
- return 0, err37
- }
- i += n37
- }
- if m.WinSpec != nil {
- dAtA[i] = 0x72
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.WinSpec.ProtoSize()))
- n38, err38 := m.WinSpec.MarshalTo(dAtA[i:])
- if err38 != nil {
- return 0, err38
+ {
+ size, err := m.UpdateInfo.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n38
+ i--
+ dAtA[i] = 0x6a
}
- if m.Limit != nil {
- dAtA[i] = 0x7a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Limit.ProtoSize()))
- n39, err39 := m.Limit.MarshalTo(dAtA[i:])
- if err39 != nil {
- return 0, err39
+ if len(m.OrderBy) > 0 {
+ for iNdEx := len(m.OrderBy) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.OrderBy[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x62
}
- i += n39
}
- if m.Offset != nil {
- dAtA[i] = 0x82
- i++
- dAtA[i] = 0x1
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Offset.ProtoSize()))
- n40, err40 := m.Offset.MarshalTo(dAtA[i:])
- if err40 != nil {
- return 0, err40
+ if len(m.AggList) > 0 {
+ for iNdEx := len(m.AggList) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.AggList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x5a
}
- i += n40
}
- if m.TableDef != nil {
- dAtA[i] = 0x8a
- i++
- dAtA[i] = 0x1
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.TableDef.ProtoSize()))
- n41, err41 := m.TableDef.MarshalTo(dAtA[i:])
- if err41 != nil {
- return 0, err41
+ if len(m.GroupingSet) > 0 {
+ for iNdEx := len(m.GroupingSet) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.GroupingSet[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x52
}
- i += n41
}
- if m.ObjRef != nil {
- dAtA[i] = 0x92
- i++
- dAtA[i] = 0x1
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.ObjRef.ProtoSize()))
- n42, err42 := m.ObjRef.MarshalTo(dAtA[i:])
- if err42 != nil {
- return 0, err42
+ if len(m.GroupBy) > 0 {
+ for iNdEx := len(m.GroupBy) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.GroupBy[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x4a
}
- i += n42
}
- if m.RowsetData != nil {
- dAtA[i] = 0x9a
- i++
- dAtA[i] = 0x1
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.RowsetData.ProtoSize()))
- n43, err43 := m.RowsetData.MarshalTo(dAtA[i:])
- if err43 != nil {
- return 0, err43
+ if len(m.FilterList) > 0 {
+ for iNdEx := len(m.FilterList) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.FilterList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x42
}
- i += n43
- }
- if len(m.ExtraOptions) > 0 {
- dAtA[i] = 0xa2
- i++
- dAtA[i] = 0x1
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.ExtraOptions)))
- i += copy(dAtA[i:], m.ExtraOptions)
}
- if len(m.DeleteTablesCtx) > 0 {
- for _, msg := range m.DeleteTablesCtx {
- dAtA[i] = 0xaa
- i++
- dAtA[i] = 0x1
- i++
- i = encodeVarintPlan(dAtA, i, uint64(msg.ProtoSize()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
+ if len(m.OnList) > 0 {
+ for iNdEx := len(m.OnList) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.OnList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n
+ i--
+ dAtA[i] = 0x3a
}
}
- if len(m.BindingTags) > 0 {
- dAtA45 := make([]byte, len(m.BindingTags)*10)
- var j44 int
- for _, num1 := range m.BindingTags {
+ if m.JoinType != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.JoinType))
+ i--
+ dAtA[i] = 0x30
+ }
+ if len(m.Children) > 0 {
+ dAtA41 := make([]byte, len(m.Children)*10)
+ var j40 int
+ for _, num1 := range m.Children {
num := uint64(num1)
for num >= 1<<7 {
- dAtA45[j44] = uint8(uint64(num)&0x7f | 0x80)
+ dAtA41[j40] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
- j44++
+ j40++
}
- dAtA45[j44] = uint8(num)
- j44++
+ dAtA41[j40] = uint8(num)
+ j40++
}
- dAtA[i] = 0xb2
- i++
- dAtA[i] = 0x1
- i++
- i = encodeVarintPlan(dAtA, i, uint64(j44))
- i += copy(dAtA[i:], dAtA45[:j44])
+ i -= j40
+ copy(dAtA[i:], dAtA41[:j40])
+ i = encodeVarintPlan(dAtA, i, uint64(j40))
+ i--
+ dAtA[i] = 0x2a
}
- if m.AnalyzeInfo != nil {
- dAtA[i] = 0xba
- i++
- dAtA[i] = 0x1
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.AnalyzeInfo.ProtoSize()))
- n46, err46 := m.AnalyzeInfo.MarshalTo(dAtA[i:])
- if err46 != nil {
- return 0, err46
+ if len(m.ProjectList) > 0 {
+ for iNdEx := len(m.ProjectList) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.ProjectList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x22
}
- i += n46
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.Cost != nil {
+ {
+ size, err := m.Cost.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x1a
+ }
+ if m.NodeId != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.NodeId))
+ i--
+ dAtA[i] = 0x10
+ }
+ if m.NodeType != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.NodeType))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DeleteTableCtx) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -8708,48 +7983,57 @@ func (m *DeleteTableCtx) Marshal() (dAtA []byte, err error) {
}
func (m *DeleteTableCtx) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DeleteTableCtx) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.DbName) > 0 {
- dAtA[i] = 0xa
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.DbName)))
- i += copy(dAtA[i:], m.DbName)
- }
- if len(m.TblName) > 0 {
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.TblName)))
- i += copy(dAtA[i:], m.TblName)
- }
- if len(m.UseDeleteKey) > 0 {
- dAtA[i] = 0x1a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.UseDeleteKey)))
- i += copy(dAtA[i:], m.UseDeleteKey)
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if m.CanTruncate {
- dAtA[i] = 0x20
- i++
+ i--
if m.CanTruncate {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
- i++
+ i--
+ dAtA[i] = 0x20
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.UseDeleteKey) > 0 {
+ i -= len(m.UseDeleteKey)
+ copy(dAtA[i:], m.UseDeleteKey)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.UseDeleteKey)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ if len(m.TblName) > 0 {
+ i -= len(m.TblName)
+ copy(dAtA[i:], m.TblName)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.TblName)))
+ i--
+ dAtA[i] = 0x12
}
- return i, nil
+ if len(m.DbName) > 0 {
+ i -= len(m.DbName)
+ copy(dAtA[i:], m.DbName)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.DbName)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
}
func (m *Query) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -8757,82 +8041,87 @@ func (m *Query) Marshal() (dAtA []byte, err error) {
}
func (m *Query) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Query) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.StmtType != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.StmtType))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if len(m.Steps) > 0 {
- dAtA48 := make([]byte, len(m.Steps)*10)
- var j47 int
- for _, num1 := range m.Steps {
- num := uint64(num1)
- for num >= 1<<7 {
- dAtA48[j47] = uint8(uint64(num)&0x7f | 0x80)
- num >>= 7
- j47++
- }
- dAtA48[j47] = uint8(num)
- j47++
+ if len(m.Headings) > 0 {
+ for iNdEx := len(m.Headings) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(m.Headings[iNdEx])
+ copy(dAtA[i:], m.Headings[iNdEx])
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.Headings[iNdEx])))
+ i--
+ dAtA[i] = 0x2a
}
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(j47))
- i += copy(dAtA[i:], dAtA48[:j47])
}
- if len(m.Nodes) > 0 {
- for _, msg := range m.Nodes {
- dAtA[i] = 0x1a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(msg.ProtoSize()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
+ if len(m.Params) > 0 {
+ for iNdEx := len(m.Params) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Params[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n
+ i--
+ dAtA[i] = 0x22
}
}
- if len(m.Params) > 0 {
- for _, msg := range m.Params {
- dAtA[i] = 0x22
- i++
- i = encodeVarintPlan(dAtA, i, uint64(msg.ProtoSize()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
+ if len(m.Nodes) > 0 {
+ for iNdEx := len(m.Nodes) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Nodes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n
+ i--
+ dAtA[i] = 0x1a
}
}
- if len(m.Headings) > 0 {
- for _, s := range m.Headings {
- dAtA[i] = 0x2a
- i++
- l = len(s)
- for l >= 1<<7 {
- dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
- l >>= 7
- i++
+ if len(m.Steps) > 0 {
+ dAtA44 := make([]byte, len(m.Steps)*10)
+ var j43 int
+ for _, num1 := range m.Steps {
+ num := uint64(num1)
+ for num >= 1<<7 {
+ dAtA44[j43] = uint8(uint64(num)&0x7f | 0x80)
+ num >>= 7
+ j43++
}
- dAtA[i] = uint8(l)
- i++
- i += copy(dAtA[i:], s)
+ dAtA44[j43] = uint8(num)
+ j43++
}
+ i -= j43
+ copy(dAtA[i:], dAtA44[:j43])
+ i = encodeVarintPlan(dAtA, i, uint64(j43))
+ i--
+ dAtA[i] = 0x12
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.StmtType != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.StmtType))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TransationControl) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -8840,74 +8129,103 @@ func (m *TransationControl) Marshal() (dAtA []byte, err error) {
}
func (m *TransationControl) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TransationControl) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.TclType != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.TclType))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if m.Action != nil {
- nn49, err49 := m.Action.MarshalTo(dAtA[i:])
- if err49 != nil {
- return 0, err49
+ {
+ size := m.Action.ProtoSize()
+ i -= size
+ if _, err := m.Action.MarshalTo(dAtA[i:]); err != nil {
+ return 0, err
+ }
}
- i += nn49
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.TclType != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.TclType))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TransationControl_Begin) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TransationControl_Begin) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.Begin != nil {
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Begin.ProtoSize()))
- n50, err50 := m.Begin.MarshalTo(dAtA[i:])
- if err50 != nil {
- return 0, err50
+ {
+ size, err := m.Begin.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n50
+ i--
+ dAtA[i] = 0x12
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TransationControl_Commit) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TransationControl_Commit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.Commit != nil {
- dAtA[i] = 0x1a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Commit.ProtoSize()))
- n51, err51 := m.Commit.MarshalTo(dAtA[i:])
- if err51 != nil {
- return 0, err51
+ {
+ size, err := m.Commit.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n51
+ i--
+ dAtA[i] = 0x1a
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TransationControl_Rollback) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TransationControl_Rollback) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.Rollback != nil {
- dAtA[i] = 0x22
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Rollback.ProtoSize()))
- n52, err52 := m.Rollback.MarshalTo(dAtA[i:])
- if err52 != nil {
- return 0, err52
+ {
+ size, err := m.Rollback.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n52
+ i--
+ dAtA[i] = 0x22
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TransationBegin) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -8915,25 +8233,31 @@ func (m *TransationBegin) Marshal() (dAtA []byte, err error) {
}
func (m *TransationBegin) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TransationBegin) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if m.Mode != 0 {
- dAtA[i] = 0x8
- i++
i = encodeVarintPlan(dAtA, i, uint64(m.Mode))
+ i--
+ dAtA[i] = 0x8
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
- }
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TransationCommit) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -8941,25 +8265,31 @@ func (m *TransationCommit) Marshal() (dAtA []byte, err error) {
}
func (m *TransationCommit) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TransationCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if m.CompletionType != 0 {
- dAtA[i] = 0x8
- i++
i = encodeVarintPlan(dAtA, i, uint64(m.CompletionType))
+ i--
+ dAtA[i] = 0x8
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
- }
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TransationRollback) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -8967,25 +8297,31 @@ func (m *TransationRollback) Marshal() (dAtA []byte, err error) {
}
func (m *TransationRollback) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TransationRollback) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if m.CompletionType != 0 {
- dAtA[i] = 0x8
- i++
i = encodeVarintPlan(dAtA, i, uint64(m.CompletionType))
+ i--
+ dAtA[i] = 0x8
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
- }
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Plan) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -8993,83 +8329,119 @@ func (m *Plan) Marshal() (dAtA []byte, err error) {
}
func (m *Plan) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Plan) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if m.Plan != nil {
- nn53, err53 := m.Plan.MarshalTo(dAtA[i:])
- if err53 != nil {
- return 0, err53
+ {
+ size := m.Plan.ProtoSize()
+ i -= size
+ if _, err := m.Plan.MarshalTo(dAtA[i:]); err != nil {
+ return 0, err
+ }
}
- i += nn53
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Plan_Query) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Plan_Query) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.Query != nil {
- dAtA[i] = 0xa
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Query.ProtoSize()))
- n54, err54 := m.Query.MarshalTo(dAtA[i:])
- if err54 != nil {
- return 0, err54
+ {
+ size, err := m.Query.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n54
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Plan_Tcl) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Plan_Tcl) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.Tcl != nil {
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Tcl.ProtoSize()))
- n55, err55 := m.Tcl.MarshalTo(dAtA[i:])
- if err55 != nil {
- return 0, err55
+ {
+ size, err := m.Tcl.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n55
+ i--
+ dAtA[i] = 0x12
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Plan_Ddl) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Plan_Ddl) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.Ddl != nil {
- dAtA[i] = 0x1a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Ddl.ProtoSize()))
- n56, err56 := m.Ddl.MarshalTo(dAtA[i:])
- if err56 != nil {
- return 0, err56
+ {
+ size, err := m.Ddl.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n56
+ i--
+ dAtA[i] = 0x1a
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Plan_Dcl) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Plan_Dcl) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.Dcl != nil {
- dAtA[i] = 0x22
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Dcl.ProtoSize()))
- n57, err57 := m.Dcl.MarshalTo(dAtA[i:])
- if err57 != nil {
- return 0, err57
+ {
+ size, err := m.Dcl.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n57
+ i--
+ dAtA[i] = 0x22
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DataControl) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -9077,88 +8449,124 @@ func (m *DataControl) Marshal() (dAtA []byte, err error) {
}
func (m *DataControl) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DataControl) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.DclType != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.DclType))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if m.Control != nil {
- nn58, err58 := m.Control.MarshalTo(dAtA[i:])
- if err58 != nil {
- return 0, err58
+ {
+ size := m.Control.ProtoSize()
+ i -= size
+ if _, err := m.Control.MarshalTo(dAtA[i:]); err != nil {
+ return 0, err
+ }
}
- i += nn58
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.DclType != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.DclType))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DataControl_SetVariables) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DataControl_SetVariables) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.SetVariables != nil {
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.SetVariables.ProtoSize()))
- n59, err59 := m.SetVariables.MarshalTo(dAtA[i:])
- if err59 != nil {
- return 0, err59
+ {
+ size, err := m.SetVariables.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n59
+ i--
+ dAtA[i] = 0x12
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DataControl_Prepare) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DataControl_Prepare) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.Prepare != nil {
- dAtA[i] = 0x1a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Prepare.ProtoSize()))
- n60, err60 := m.Prepare.MarshalTo(dAtA[i:])
- if err60 != nil {
- return 0, err60
+ {
+ size, err := m.Prepare.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n60
+ i--
+ dAtA[i] = 0x1a
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DataControl_Execute) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DataControl_Execute) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.Execute != nil {
- dAtA[i] = 0x22
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Execute.ProtoSize()))
- n61, err61 := m.Execute.MarshalTo(dAtA[i:])
- if err61 != nil {
- return 0, err61
+ {
+ size, err := m.Execute.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n61
+ i--
+ dAtA[i] = 0x22
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DataControl_Deallocate) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DataControl_Deallocate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.Deallocate != nil {
- dAtA[i] = 0x2a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Deallocate.ProtoSize()))
- n62, err62 := m.Deallocate.MarshalTo(dAtA[i:])
- if err62 != nil {
- return 0, err62
+ {
+ size, err := m.Deallocate.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n62
+ i--
+ dAtA[i] = 0x2a
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DataDefinition) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -9166,196 +8574,283 @@ func (m *DataDefinition) Marshal() (dAtA []byte, err error) {
}
func (m *DataDefinition) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DataDefinition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.DdlType != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.DdlType))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if m.Query != nil {
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Query.ProtoSize()))
- n63, err63 := m.Query.MarshalTo(dAtA[i:])
- if err63 != nil {
- return 0, err63
+ if m.Definition != nil {
+ {
+ size := m.Definition.ProtoSize()
+ i -= size
+ if _, err := m.Definition.MarshalTo(dAtA[i:]); err != nil {
+ return 0, err
+ }
}
- i += n63
}
- if m.Definition != nil {
- nn64, err64 := m.Definition.MarshalTo(dAtA[i:])
- if err64 != nil {
- return 0, err64
+ if m.Query != nil {
+ {
+ size, err := m.Query.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += nn64
+ i--
+ dAtA[i] = 0x12
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.DdlType != 0 {
+ i = encodeVarintPlan(dAtA, i, uint64(m.DdlType))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DataDefinition_CreateDatabase) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DataDefinition_CreateDatabase) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.CreateDatabase != nil {
- dAtA[i] = 0x1a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.CreateDatabase.ProtoSize()))
- n65, err65 := m.CreateDatabase.MarshalTo(dAtA[i:])
- if err65 != nil {
- return 0, err65
+ {
+ size, err := m.CreateDatabase.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n65
+ i--
+ dAtA[i] = 0x1a
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DataDefinition_AlterDatabase) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DataDefinition_AlterDatabase) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.AlterDatabase != nil {
- dAtA[i] = 0x22
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.AlterDatabase.ProtoSize()))
- n66, err66 := m.AlterDatabase.MarshalTo(dAtA[i:])
- if err66 != nil {
- return 0, err66
+ {
+ size, err := m.AlterDatabase.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n66
+ i--
+ dAtA[i] = 0x22
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DataDefinition_DropDatabase) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DataDefinition_DropDatabase) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.DropDatabase != nil {
- dAtA[i] = 0x2a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.DropDatabase.ProtoSize()))
- n67, err67 := m.DropDatabase.MarshalTo(dAtA[i:])
- if err67 != nil {
- return 0, err67
+ {
+ size, err := m.DropDatabase.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n67
+ i--
+ dAtA[i] = 0x2a
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DataDefinition_CreateTable) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DataDefinition_CreateTable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.CreateTable != nil {
- dAtA[i] = 0x32
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.CreateTable.ProtoSize()))
- n68, err68 := m.CreateTable.MarshalTo(dAtA[i:])
- if err68 != nil {
- return 0, err68
+ {
+ size, err := m.CreateTable.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n68
+ i--
+ dAtA[i] = 0x32
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DataDefinition_AlterTable) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DataDefinition_AlterTable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.AlterTable != nil {
- dAtA[i] = 0x3a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.AlterTable.ProtoSize()))
- n69, err69 := m.AlterTable.MarshalTo(dAtA[i:])
- if err69 != nil {
- return 0, err69
+ {
+ size, err := m.AlterTable.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n69
+ i--
+ dAtA[i] = 0x3a
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DataDefinition_DropTable) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DataDefinition_DropTable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.DropTable != nil {
- dAtA[i] = 0x42
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.DropTable.ProtoSize()))
- n70, err70 := m.DropTable.MarshalTo(dAtA[i:])
- if err70 != nil {
- return 0, err70
+ {
+ size, err := m.DropTable.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n70
+ i--
+ dAtA[i] = 0x42
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DataDefinition_CreateIndex) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DataDefinition_CreateIndex) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.CreateIndex != nil {
- dAtA[i] = 0x4a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.CreateIndex.ProtoSize()))
- n71, err71 := m.CreateIndex.MarshalTo(dAtA[i:])
- if err71 != nil {
- return 0, err71
+ {
+ size, err := m.CreateIndex.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n71
+ i--
+ dAtA[i] = 0x4a
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DataDefinition_AlterIndex) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DataDefinition_AlterIndex) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.AlterIndex != nil {
- dAtA[i] = 0x52
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.AlterIndex.ProtoSize()))
- n72, err72 := m.AlterIndex.MarshalTo(dAtA[i:])
- if err72 != nil {
- return 0, err72
+ {
+ size, err := m.AlterIndex.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n72
+ i--
+ dAtA[i] = 0x52
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DataDefinition_DropIndex) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DataDefinition_DropIndex) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.DropIndex != nil {
- dAtA[i] = 0x5a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.DropIndex.ProtoSize()))
- n73, err73 := m.DropIndex.MarshalTo(dAtA[i:])
- if err73 != nil {
- return 0, err73
+ {
+ size, err := m.DropIndex.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n73
+ i--
+ dAtA[i] = 0x5a
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DataDefinition_TruncateTable) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DataDefinition_TruncateTable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.TruncateTable != nil {
- dAtA[i] = 0x62
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.TruncateTable.ProtoSize()))
- n74, err74 := m.TruncateTable.MarshalTo(dAtA[i:])
- if err74 != nil {
- return 0, err74
+ {
+ size, err := m.TruncateTable.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n74
+ i--
+ dAtA[i] = 0x62
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DataDefinition_ShowVariables) MarshalTo(dAtA []byte) (int, error) {
- i := 0
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DataDefinition_ShowVariables) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
if m.ShowVariables != nil {
- dAtA[i] = 0x6a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.ShowVariables.ProtoSize()))
- n75, err75 := m.ShowVariables.MarshalTo(dAtA[i:])
- if err75 != nil {
- return 0, err75
+ {
+ size, err := m.ShowVariables.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n75
+ i--
+ dAtA[i] = 0x6a
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *CreateDatabase) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -9363,36 +8858,43 @@ func (m *CreateDatabase) Marshal() (dAtA []byte, err error) {
}
func (m *CreateDatabase) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CreateDatabase) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
+ if len(m.Database) > 0 {
+ i -= len(m.Database)
+ copy(dAtA[i:], m.Database)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.Database)))
+ i--
+ dAtA[i] = 0x12
+ }
if m.IfNotExists {
- dAtA[i] = 0x8
- i++
+ i--
if m.IfNotExists {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
- i++
- }
- if len(m.Database) > 0 {
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.Database)))
- i += copy(dAtA[i:], m.Database)
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *AlterDatabase) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -9400,36 +8902,43 @@ func (m *AlterDatabase) Marshal() (dAtA []byte, err error) {
}
func (m *AlterDatabase) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AlterDatabase) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
+ if len(m.Database) > 0 {
+ i -= len(m.Database)
+ copy(dAtA[i:], m.Database)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.Database)))
+ i--
+ dAtA[i] = 0x12
+ }
if m.IfExists {
- dAtA[i] = 0x8
- i++
+ i--
if m.IfExists {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
- i++
- }
- if len(m.Database) > 0 {
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.Database)))
- i += copy(dAtA[i:], m.Database)
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DropDatabase) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -9437,36 +8946,43 @@ func (m *DropDatabase) Marshal() (dAtA []byte, err error) {
}
func (m *DropDatabase) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DropDatabase) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
+ if len(m.Database) > 0 {
+ i -= len(m.Database)
+ copy(dAtA[i:], m.Database)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.Database)))
+ i--
+ dAtA[i] = 0x12
+ }
if m.IfExists {
- dAtA[i] = 0x8
- i++
+ i--
if m.IfExists {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
- i++
- }
- if len(m.Database) > 0 {
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.Database)))
- i += copy(dAtA[i:], m.Database)
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *CreateTable) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -9474,56 +8990,65 @@ func (m *CreateTable) Marshal() (dAtA []byte, err error) {
}
func (m *CreateTable) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CreateTable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.IfNotExists {
- dAtA[i] = 0x8
- i++
- if m.IfNotExists {
- dAtA[i] = 1
- } else {
- dAtA[i] = 0
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
+ if m.TableDef != nil {
+ {
+ size, err := m.TableDef.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i++
+ i--
+ dAtA[i] = 0x22
+ }
+ if len(m.Database) > 0 {
+ i -= len(m.Database)
+ copy(dAtA[i:], m.Database)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.Database)))
+ i--
+ dAtA[i] = 0x1a
}
if m.Temporary {
- dAtA[i] = 0x10
- i++
+ i--
if m.Temporary {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
- i++
- }
- if len(m.Database) > 0 {
- dAtA[i] = 0x1a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.Database)))
- i += copy(dAtA[i:], m.Database)
+ i--
+ dAtA[i] = 0x10
}
- if m.TableDef != nil {
- dAtA[i] = 0x22
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.TableDef.ProtoSize()))
- n76, err76 := m.TableDef.MarshalTo(dAtA[i:])
- if err76 != nil {
- return 0, err76
+ if m.IfNotExists {
+ i--
+ if m.IfNotExists {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
}
- i += n76
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *AlterTable) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -9531,36 +9056,45 @@ func (m *AlterTable) Marshal() (dAtA []byte, err error) {
}
func (m *AlterTable) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AlterTable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.Table) > 0 {
- dAtA[i] = 0xa
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.Table)))
- i += copy(dAtA[i:], m.Table)
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if m.TableDef != nil {
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.TableDef.ProtoSize()))
- n77, err77 := m.TableDef.MarshalTo(dAtA[i:])
- if err77 != nil {
- return 0, err77
+ {
+ size, err := m.TableDef.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n77
+ i--
+ dAtA[i] = 0x12
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.Table) > 0 {
+ i -= len(m.Table)
+ copy(dAtA[i:], m.Table)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.Table)))
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DropTable) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -9568,42 +9102,50 @@ func (m *DropTable) Marshal() (dAtA []byte, err error) {
}
func (m *DropTable) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DropTable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
+ if len(m.Table) > 0 {
+ i -= len(m.Table)
+ copy(dAtA[i:], m.Table)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.Table)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ if len(m.Database) > 0 {
+ i -= len(m.Database)
+ copy(dAtA[i:], m.Database)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.Database)))
+ i--
+ dAtA[i] = 0x12
+ }
if m.IfExists {
- dAtA[i] = 0x8
- i++
+ i--
if m.IfExists {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
- i++
- }
- if len(m.Database) > 0 {
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.Database)))
- i += copy(dAtA[i:], m.Database)
- }
- if len(m.Table) > 0 {
- dAtA[i] = 0x1a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.Table)))
- i += copy(dAtA[i:], m.Table)
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *CreateIndex) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -9611,36 +9153,43 @@ func (m *CreateIndex) Marshal() (dAtA []byte, err error) {
}
func (m *CreateIndex) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CreateIndex) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
+ if len(m.Index) > 0 {
+ i -= len(m.Index)
+ copy(dAtA[i:], m.Index)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.Index)))
+ i--
+ dAtA[i] = 0x12
+ }
if m.IfNotExists {
- dAtA[i] = 0x8
- i++
+ i--
if m.IfNotExists {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
- i++
- }
- if len(m.Index) > 0 {
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.Index)))
- i += copy(dAtA[i:], m.Index)
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *AlterIndex) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -9648,26 +9197,33 @@ func (m *AlterIndex) Marshal() (dAtA []byte, err error) {
}
func (m *AlterIndex) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AlterIndex) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if len(m.Index) > 0 {
- dAtA[i] = 0xa
- i++
+ i -= len(m.Index)
+ copy(dAtA[i:], m.Index)
i = encodeVarintPlan(dAtA, i, uint64(len(m.Index)))
- i += copy(dAtA[i:], m.Index)
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *DropIndex) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -9675,36 +9231,43 @@ func (m *DropIndex) Marshal() (dAtA []byte, err error) {
}
func (m *DropIndex) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DropIndex) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
+ if len(m.Index) > 0 {
+ i -= len(m.Index)
+ copy(dAtA[i:], m.Index)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.Index)))
+ i--
+ dAtA[i] = 0x12
+ }
if m.IfExists {
- dAtA[i] = 0x8
- i++
+ i--
if m.IfExists {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
- i++
- }
- if len(m.Index) > 0 {
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.Index)))
- i += copy(dAtA[i:], m.Index)
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TruncateTable) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -9712,26 +9275,33 @@ func (m *TruncateTable) Marshal() (dAtA []byte, err error) {
}
func (m *TruncateTable) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TruncateTable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if len(m.Table) > 0 {
- dAtA[i] = 0xa
- i++
+ i -= len(m.Table)
+ copy(dAtA[i:], m.Table)
i = encodeVarintPlan(dAtA, i, uint64(len(m.Table)))
- i += copy(dAtA[i:], m.Table)
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *ShowVariables) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -9739,42 +9309,50 @@ func (m *ShowVariables) Marshal() (dAtA []byte, err error) {
}
func (m *ShowVariables) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ShowVariables) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
+ if len(m.Where) > 0 {
+ for iNdEx := len(m.Where) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Where[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x12
+ }
+ }
if m.Global {
- dAtA[i] = 0x8
- i++
+ i--
if m.Global {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
- i++
- }
- if len(m.Where) > 0 {
- for _, msg := range m.Where {
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(msg.ProtoSize()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
- }
- i += n
- }
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *SetVariables) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -9782,32 +9360,40 @@ func (m *SetVariables) Marshal() (dAtA []byte, err error) {
}
func (m *SetVariables) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *SetVariables) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if len(m.Items) > 0 {
- for _, msg := range m.Items {
- dAtA[i] = 0xa
- i++
- i = encodeVarintPlan(dAtA, i, uint64(msg.ProtoSize()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
+ for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n
+ i--
+ dAtA[i] = 0xa
}
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
- }
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *SetVariablesItem) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -9815,66 +9401,77 @@ func (m *SetVariablesItem) Marshal() (dAtA []byte, err error) {
}
func (m *SetVariablesItem) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *SetVariablesItem) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.System {
- dAtA[i] = 0x8
- i++
- if m.System {
- dAtA[i] = 1
- } else {
- dAtA[i] = 0
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
+ if m.Reserved != nil {
+ {
+ size, err := m.Reserved.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i++
+ i--
+ dAtA[i] = 0x2a
}
- if m.Global {
- dAtA[i] = 0x10
- i++
- if m.Global {
- dAtA[i] = 1
- } else {
- dAtA[i] = 0
+ if m.Value != nil {
+ {
+ size, err := m.Value.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i++
+ i--
+ dAtA[i] = 0x22
}
if len(m.Name) > 0 {
- dAtA[i] = 0x1a
- i++
+ i -= len(m.Name)
+ copy(dAtA[i:], m.Name)
i = encodeVarintPlan(dAtA, i, uint64(len(m.Name)))
- i += copy(dAtA[i:], m.Name)
+ i--
+ dAtA[i] = 0x1a
}
- if m.Value != nil {
- dAtA[i] = 0x22
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Value.ProtoSize()))
- n78, err78 := m.Value.MarshalTo(dAtA[i:])
- if err78 != nil {
- return 0, err78
+ if m.Global {
+ i--
+ if m.Global {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
}
- i += n78
+ i--
+ dAtA[i] = 0x10
}
- if m.Reserved != nil {
- dAtA[i] = 0x2a
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Reserved.ProtoSize()))
- n79, err79 := m.Reserved.MarshalTo(dAtA[i:])
- if err79 != nil {
- return 0, err79
+ if m.System {
+ i--
+ if m.System {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
}
- i += n79
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Prepare) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -9882,36 +9479,45 @@ func (m *Prepare) Marshal() (dAtA []byte, err error) {
}
func (m *Prepare) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Prepare) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.Name) > 0 {
- dAtA[i] = 0xa
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.Name)))
- i += copy(dAtA[i:], m.Name)
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if m.Plan != nil {
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(m.Plan.ProtoSize()))
- n80, err80 := m.Plan.MarshalTo(dAtA[i:])
- if err80 != nil {
- return 0, err80
+ {
+ size, err := m.Plan.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n80
+ i--
+ dAtA[i] = 0x12
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.Name) > 0 {
+ i -= len(m.Name)
+ copy(dAtA[i:], m.Name)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.Name)))
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Execute) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -9919,38 +9525,47 @@ func (m *Execute) Marshal() (dAtA []byte, err error) {
}
func (m *Execute) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Execute) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.Name) > 0 {
- dAtA[i] = 0xa
- i++
- i = encodeVarintPlan(dAtA, i, uint64(len(m.Name)))
- i += copy(dAtA[i:], m.Name)
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Args) > 0 {
- for _, msg := range m.Args {
- dAtA[i] = 0x12
- i++
- i = encodeVarintPlan(dAtA, i, uint64(msg.ProtoSize()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
+ for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Args[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintPlan(dAtA, i, uint64(size))
}
- i += n
+ i--
+ dAtA[i] = 0x12
}
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if len(m.Name) > 0 {
+ i -= len(m.Name)
+ copy(dAtA[i:], m.Name)
+ i = encodeVarintPlan(dAtA, i, uint64(len(m.Name)))
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *Deallocate) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -9958,30 +9573,39 @@ func (m *Deallocate) Marshal() (dAtA []byte, err error) {
}
func (m *Deallocate) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.ProtoSize()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Deallocate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if len(m.Name) > 0 {
- dAtA[i] = 0xa
- i++
+ i -= len(m.Name)
+ copy(dAtA[i:], m.Name)
i = encodeVarintPlan(dAtA, i, uint64(len(m.Name)))
- i += copy(dAtA[i:], m.Name)
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func encodeVarintPlan(dAtA []byte, offset int, v uint64) int {
+ offset -= sovPlan(v)
+ base := offset
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
- return offset + 1
+ return base
}
func (m *Type) ProtoSize() (n int) {
if m == nil {
@@ -12092,10 +11716,7 @@ func (m *Type) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -12396,10 +12017,7 @@ func (m *Const) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -12469,10 +12087,7 @@ func (m *ParamRef) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -12555,10 +12170,7 @@ func (m *VarRef) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -12679,10 +12291,7 @@ func (m *ColRef) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -12790,10 +12399,7 @@ func (m *CorrColRef) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -12878,10 +12484,7 @@ func (m *ExprList) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -12968,10 +12571,7 @@ func (m *TargetType) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -13128,10 +12728,7 @@ func (m *SubqueryRef) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -13386,10 +12983,7 @@ func (m *ObjectRef) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -13510,10 +13104,7 @@ func (m *Function) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -13915,10 +13506,7 @@ func (m *Expr) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -14045,10 +13633,7 @@ func (m *DefaultExpr) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -14349,10 +13934,7 @@ func (m *ConstantValue) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -14441,10 +14023,7 @@ func (m *Decimal128) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -14689,10 +14268,7 @@ func (m *ColDef) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -14826,10 +14402,7 @@ func (m *IndexDef) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -14912,10 +14485,7 @@ func (m *PrimaryKeyDef) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -15030,10 +14600,7 @@ func (m *Property) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -15118,10 +14685,7 @@ func (m *PropertiesDef) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -15272,10 +14836,7 @@ func (m *TableDef) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -15431,10 +14992,7 @@ func (m *TableDef_DefType) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -15540,10 +15098,7 @@ func (m *Cost) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -15994,10 +15549,7 @@ func (m *ColData) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -16118,10 +15670,7 @@ func (m *RowsetData) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -16259,10 +15808,7 @@ func (m *OrderBySpec) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -16419,10 +15965,7 @@ func (m *WindowSpec) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -16652,10 +16195,7 @@ func (m *UpdateInfo) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -16820,10 +16360,7 @@ func (m *AnalyzeInfo) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -17711,10 +17248,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -17881,10 +17415,7 @@ func (m *DeleteTableCtx) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -18130,10 +17661,7 @@ func (m *Query) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -18308,10 +17836,7 @@ func (m *TransationControl) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -18381,10 +17906,7 @@ func (m *TransationBegin) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -18454,10 +17976,7 @@ func (m *TransationCommit) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -18527,10 +18046,7 @@ func (m *TransationRollback) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -18721,10 +18237,7 @@ func (m *Plan) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -18934,10 +18447,7 @@ func (m *DataControl) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -19428,10 +18938,7 @@ func (m *DataDefinition) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -19534,10 +19041,7 @@ func (m *CreateDatabase) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -19640,10 +19144,7 @@ func (m *AlterDatabase) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -19746,10 +19247,7 @@ func (m *DropDatabase) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -19908,10 +19406,7 @@ func (m *CreateTable) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -20030,10 +19525,7 @@ func (m *AlterTable) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -20168,10 +19660,7 @@ func (m *DropTable) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -20274,10 +19763,7 @@ func (m *CreateIndex) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -20360,10 +19846,7 @@ func (m *AlterIndex) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -20466,10 +19949,7 @@ func (m *DropIndex) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -20552,10 +20032,7 @@ func (m *TruncateTable) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -20660,10 +20137,7 @@ func (m *ShowVariables) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -20748,10 +20222,7 @@ func (m *SetVariables) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -20946,10 +20417,7 @@ func (m *SetVariablesItem) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -21068,10 +20536,7 @@ func (m *Prepare) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -21188,10 +20653,7 @@ func (m *Execute) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -21274,10 +20736,7 @@ func (m *Deallocate) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthPlan
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthPlan
}
if (iNdEx + skippy) > l {
@@ -21296,6 +20755,7 @@ func (m *Deallocate) Unmarshal(dAtA []byte) error {
func skipPlan(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
+ depth := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
@@ -21327,10 +20787,8 @@ func skipPlan(dAtA []byte) (n int, err error) {
break
}
}
- return iNdEx, nil
case 1:
iNdEx += 8
- return iNdEx, nil
case 2:
var length int
for shift := uint(0); ; shift += 7 {
@@ -21351,55 +20809,30 @@ func skipPlan(dAtA []byte) (n int, err error) {
return 0, ErrInvalidLengthPlan
}
iNdEx += length
- if iNdEx < 0 {
- return 0, ErrInvalidLengthPlan
- }
- return iNdEx, nil
case 3:
- for {
- var innerWire uint64
- var start int = iNdEx
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return 0, ErrIntOverflowPlan
- }
- if iNdEx >= l {
- return 0, io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- innerWire |= (uint64(b) & 0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- innerWireType := int(innerWire & 0x7)
- if innerWireType == 4 {
- break
- }
- next, err := skipPlan(dAtA[start:])
- if err != nil {
- return 0, err
- }
- iNdEx = start + next
- if iNdEx < 0 {
- return 0, ErrInvalidLengthPlan
- }
- }
- return iNdEx, nil
+ depth++
case 4:
- return iNdEx, nil
+ if depth == 0 {
+ return 0, ErrUnexpectedEndOfGroupPlan
+ }
+ depth--
case 5:
iNdEx += 4
- return iNdEx, nil
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
+ if iNdEx < 0 {
+ return 0, ErrInvalidLengthPlan
+ }
+ if depth == 0 {
+ return iNdEx, nil
+ }
}
- panic("unreachable")
+ return 0, io.ErrUnexpectedEOF
}
var (
- ErrInvalidLengthPlan = fmt.Errorf("proto: negative length found during unmarshaling")
- ErrIntOverflowPlan = fmt.Errorf("proto: integer overflow")
+ ErrInvalidLengthPlan = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowPlan = fmt.Errorf("proto: integer overflow")
+ ErrUnexpectedEndOfGroupPlan = fmt.Errorf("proto: unexpected end of group")
)
diff --git a/pkg/pb/timestamp/timestamp.pb.go b/pkg/pb/timestamp/timestamp.pb.go
index 02e7aa632c6e8b72c9dae29c9c0703ca19ce8be5..5e13dcc4f21452f893164d80af3afe3f99e1ce0b 100644
--- a/pkg/pb/timestamp/timestamp.pb.go
+++ b/pkg/pb/timestamp/timestamp.pb.go
@@ -21,7 +21,7 @@ var _ = math.Inf
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
// Timestamp is a HLC time value. All its field should never be accessed
// directly by its users.
@@ -53,7 +53,7 @@ func (m *Timestamp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Timestamp.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -109,7 +109,7 @@ var fileDescriptor_edac929d8ae1e24f = []byte{
func (m *Timestamp) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -117,34 +117,42 @@ func (m *Timestamp) Marshal() (dAtA []byte, err error) {
}
func (m *Timestamp) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Timestamp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.PhysicalTime != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintTimestamp(dAtA, i, uint64(m.PhysicalTime))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if m.LogicalTime != 0 {
- dAtA[i] = 0x10
- i++
i = encodeVarintTimestamp(dAtA, i, uint64(m.LogicalTime))
+ i--
+ dAtA[i] = 0x10
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.PhysicalTime != 0 {
+ i = encodeVarintTimestamp(dAtA, i, uint64(m.PhysicalTime))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func encodeVarintTimestamp(dAtA []byte, offset int, v uint64) int {
+ offset -= sovTimestamp(v)
+ base := offset
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
- return offset + 1
+ return base
}
func (m *Timestamp) Size() (n int) {
if m == nil {
@@ -243,10 +251,7 @@ func (m *Timestamp) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthTimestamp
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTimestamp
}
if (iNdEx + skippy) > l {
@@ -265,6 +270,7 @@ func (m *Timestamp) Unmarshal(dAtA []byte) error {
func skipTimestamp(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
+ depth := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
@@ -296,10 +302,8 @@ func skipTimestamp(dAtA []byte) (n int, err error) {
break
}
}
- return iNdEx, nil
case 1:
iNdEx += 8
- return iNdEx, nil
case 2:
var length int
for shift := uint(0); ; shift += 7 {
@@ -320,55 +324,30 @@ func skipTimestamp(dAtA []byte) (n int, err error) {
return 0, ErrInvalidLengthTimestamp
}
iNdEx += length
- if iNdEx < 0 {
- return 0, ErrInvalidLengthTimestamp
- }
- return iNdEx, nil
case 3:
- for {
- var innerWire uint64
- var start int = iNdEx
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return 0, ErrIntOverflowTimestamp
- }
- if iNdEx >= l {
- return 0, io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- innerWire |= (uint64(b) & 0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- innerWireType := int(innerWire & 0x7)
- if innerWireType == 4 {
- break
- }
- next, err := skipTimestamp(dAtA[start:])
- if err != nil {
- return 0, err
- }
- iNdEx = start + next
- if iNdEx < 0 {
- return 0, ErrInvalidLengthTimestamp
- }
- }
- return iNdEx, nil
+ depth++
case 4:
- return iNdEx, nil
+ if depth == 0 {
+ return 0, ErrUnexpectedEndOfGroupTimestamp
+ }
+ depth--
case 5:
iNdEx += 4
- return iNdEx, nil
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
+ if iNdEx < 0 {
+ return 0, ErrInvalidLengthTimestamp
+ }
+ if depth == 0 {
+ return iNdEx, nil
+ }
}
- panic("unreachable")
+ return 0, io.ErrUnexpectedEOF
}
var (
- ErrInvalidLengthTimestamp = fmt.Errorf("proto: negative length found during unmarshaling")
- ErrIntOverflowTimestamp = fmt.Errorf("proto: integer overflow")
+ ErrInvalidLengthTimestamp = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowTimestamp = fmt.Errorf("proto: integer overflow")
+ ErrUnexpectedEndOfGroupTimestamp = fmt.Errorf("proto: unexpected end of group")
)
diff --git a/pkg/pb/txn/txn.pb.go b/pkg/pb/txn/txn.pb.go
index 8e9f26610351e2827d208f66aed8c0384b5c3331..5f735eca790a026ebc10166c95afea90fec9ed88 100644
--- a/pkg/pb/txn/txn.pb.go
+++ b/pkg/pb/txn/txn.pb.go
@@ -24,7 +24,7 @@ var _ = math.Inf
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
// TxnStatus transaction status
type TxnStatus int32
@@ -262,7 +262,7 @@ func (m *TxnMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_TxnMeta.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -352,7 +352,7 @@ func (m *CNTxnSnapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
return xxx_messageInfo_CNTxnSnapshot.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -428,7 +428,7 @@ func (m *CNOpRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_CNOpRequest.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -491,7 +491,7 @@ func (m *CNOpResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_CNOpResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -571,7 +571,7 @@ func (m *TxnRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_TxnRequest.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -731,7 +731,7 @@ func (m *TxnResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
return xxx_messageInfo_TxnResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -863,7 +863,7 @@ func (m *TxnCommitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
return xxx_messageInfo_TxnCommitRequest.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -910,7 +910,7 @@ func (m *TxnCommitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
return xxx_messageInfo_TxnCommitResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -950,7 +950,7 @@ func (m *TxnRollbackRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte,
return xxx_messageInfo_TxnRollbackRequest.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -990,7 +990,7 @@ func (m *TxnRollbackResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte,
return xxx_messageInfo_TxnRollbackResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1034,7 +1034,7 @@ func (m *TxnPrepareRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
return xxx_messageInfo_TxnPrepareRequest.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1081,7 +1081,7 @@ func (m *TxnPrepareResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte,
return xxx_messageInfo_TxnPrepareResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1123,7 +1123,7 @@ func (m *TxnGetStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte,
return xxx_messageInfo_TxnGetStatusRequest.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1170,7 +1170,7 @@ func (m *TxnGetStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte
return xxx_messageInfo_TxnGetStatusResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1213,7 +1213,7 @@ func (m *TxnCommitDNShardRequest) XXX_Marshal(b []byte, deterministic bool) ([]b
return xxx_messageInfo_TxnCommitDNShardRequest.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1260,7 +1260,7 @@ func (m *TxnCommitDNShardResponse) XXX_Marshal(b []byte, deterministic bool) ([]
return xxx_messageInfo_TxnCommitDNShardResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1302,7 +1302,7 @@ func (m *TxnRollbackDNShardRequest) XXX_Marshal(b []byte, deterministic bool) ([
return xxx_messageInfo_TxnRollbackDNShardRequest.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1349,7 +1349,7 @@ func (m *TxnRollbackDNShardResponse) XXX_Marshal(b []byte, deterministic bool) (
return xxx_messageInfo_TxnRollbackDNShardResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1391,7 +1391,7 @@ func (m *TxnRemoveMetadataRequest) XXX_Marshal(b []byte, deterministic bool) ([]
return xxx_messageInfo_TxnRemoveMetadataRequest.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1438,7 +1438,7 @@ func (m *TxnRemoveMetadataResponse) XXX_Marshal(b []byte, deterministic bool) ([
return xxx_messageInfo_TxnRemoveMetadataResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1482,7 +1482,7 @@ func (m *TxnError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_TxnError.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
- n, err := m.MarshalTo(b)
+ n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
@@ -1625,7 +1625,7 @@ var fileDescriptor_4f782e76b37adb9a = []byte{
func (m *TxnMeta) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -1633,67 +1633,82 @@ func (m *TxnMeta) Marshal() (dAtA []byte, err error) {
}
func (m *TxnMeta) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TxnMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.ID) > 0 {
- dAtA[i] = 0xa
- i++
- i = encodeVarintTxn(dAtA, i, uint64(len(m.ID)))
- i += copy(dAtA[i:], m.ID)
- }
- if m.Status != 0 {
- dAtA[i] = 0x10
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.Status))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- dAtA[i] = 0x1a
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.SnapshotTS.Size()))
- n1, err1 := m.SnapshotTS.MarshalTo(dAtA[i:])
- if err1 != nil {
- return 0, err1
+ if len(m.DNShards) > 0 {
+ for iNdEx := len(m.DNShards) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.DNShards[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x32
+ }
}
- i += n1
- dAtA[i] = 0x22
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.PreparedTS.Size()))
- n2, err2 := m.PreparedTS.MarshalTo(dAtA[i:])
- if err2 != nil {
- return 0, err2
+ {
+ size, err := m.CommitTS.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- i += n2
+ i--
dAtA[i] = 0x2a
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.CommitTS.Size()))
- n3, err3 := m.CommitTS.MarshalTo(dAtA[i:])
- if err3 != nil {
- return 0, err3
+ {
+ size, err := m.PreparedTS.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- i += n3
- if len(m.DNShards) > 0 {
- for _, msg := range m.DNShards {
- dAtA[i] = 0x32
- i++
- i = encodeVarintTxn(dAtA, i, uint64(msg.Size()))
- n, err := msg.MarshalTo(dAtA[i:])
- if err != nil {
- return 0, err
- }
- i += n
+ i--
+ dAtA[i] = 0x22
+ {
+ size, err := m.SnapshotTS.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
}
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0x1a
+ if m.Status != 0 {
+ i = encodeVarintTxn(dAtA, i, uint64(m.Status))
+ i--
+ dAtA[i] = 0x10
}
- return i, nil
+ if len(m.ID) > 0 {
+ i -= len(m.ID)
+ copy(dAtA[i:], m.ID)
+ i = encodeVarintTxn(dAtA, i, uint64(len(m.ID)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
}
func (m *CNTxnSnapshot) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -1701,58 +1716,66 @@ func (m *CNTxnSnapshot) Marshal() (dAtA []byte, err error) {
}
func (m *CNTxnSnapshot) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CNTxnSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- dAtA[i] = 0xa
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.Txn.Size()))
- n4, err4 := m.Txn.MarshalTo(dAtA[i:])
- if err4 != nil {
- return 0, err4
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- i += n4
- if m.ReadyOnly {
- dAtA[i] = 0x10
- i++
- if m.ReadyOnly {
+ if m.Disable1PCOpt {
+ i--
+ if m.Disable1PCOpt {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
- i++
+ i--
+ dAtA[i] = 0x20
}
if m.EnableCacheWrite {
- dAtA[i] = 0x18
- i++
+ i--
if m.EnableCacheWrite {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
- i++
+ i--
+ dAtA[i] = 0x18
}
- if m.Disable1PCOpt {
- dAtA[i] = 0x20
- i++
- if m.Disable1PCOpt {
+ if m.ReadyOnly {
+ i--
+ if m.ReadyOnly {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
- i++
+ i--
+ dAtA[i] = 0x10
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ {
+ size, err := m.Txn.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- return i, nil
+ i--
+ dAtA[i] = 0xa
+ return len(dAtA) - i, nil
}
func (m *CNOpRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -1760,39 +1783,48 @@ func (m *CNOpRequest) Marshal() (dAtA []byte, err error) {
}
func (m *CNOpRequest) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CNOpRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.OpCode != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.OpCode))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if len(m.Payload) > 0 {
- dAtA[i] = 0x12
- i++
- i = encodeVarintTxn(dAtA, i, uint64(len(m.Payload)))
- i += copy(dAtA[i:], m.Payload)
+ {
+ size, err := m.Target.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
+ i--
dAtA[i] = 0x1a
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.Target.Size()))
- n5, err5 := m.Target.MarshalTo(dAtA[i:])
- if err5 != nil {
- return 0, err5
+ if len(m.Payload) > 0 {
+ i -= len(m.Payload)
+ copy(dAtA[i:], m.Payload)
+ i = encodeVarintTxn(dAtA, i, uint64(len(m.Payload)))
+ i--
+ dAtA[i] = 0x12
}
- i += n5
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.OpCode != 0 {
+ i = encodeVarintTxn(dAtA, i, uint64(m.OpCode))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *CNOpResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -1800,26 +1832,33 @@ func (m *CNOpResponse) Marshal() (dAtA []byte, err error) {
}
func (m *CNOpResponse) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CNOpResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if len(m.Payload) > 0 {
- dAtA[i] = 0xa
- i++
+ i -= len(m.Payload)
+ copy(dAtA[i:], m.Payload)
i = encodeVarintTxn(dAtA, i, uint64(len(m.Payload)))
- i += copy(dAtA[i:], m.Payload)
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0xa
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TxnRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -1827,128 +1866,152 @@ func (m *TxnRequest) Marshal() (dAtA []byte, err error) {
}
func (m *TxnRequest) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TxnRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.RequestID != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.RequestID))
- }
- if m.TimeoutAt != 0 {
- dAtA[i] = 0x10
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.TimeoutAt))
- }
- dAtA[i] = 0x1a
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.Txn.Size()))
- n6, err6 := m.Txn.MarshalTo(dAtA[i:])
- if err6 != nil {
- return 0, err6
- }
- i += n6
- if m.Method != 0 {
- dAtA[i] = 0x20
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.Method))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if m.Flag != 0 {
- dAtA[i] = 0x28
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.Flag))
+ if m.RemoveMetadata != nil {
+ {
+ size, err := m.RemoveMetadata.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x6a
}
- if m.CNRequest != nil {
- dAtA[i] = 0x32
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.CNRequest.Size()))
- n7, err7 := m.CNRequest.MarshalTo(dAtA[i:])
- if err7 != nil {
- return 0, err7
+ if m.RollbackDNShardRequest != nil {
+ {
+ size, err := m.RollbackDNShardRequest.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- i += n7
+ i--
+ dAtA[i] = 0x62
}
- if m.CommitRequest != nil {
- dAtA[i] = 0x3a
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.CommitRequest.Size()))
- n8, err8 := m.CommitRequest.MarshalTo(dAtA[i:])
- if err8 != nil {
- return 0, err8
+ if m.CommitDNShardRequest != nil {
+ {
+ size, err := m.CommitDNShardRequest.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- i += n8
+ i--
+ dAtA[i] = 0x5a
}
- if m.RollbackRequest != nil {
- dAtA[i] = 0x42
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.RollbackRequest.Size()))
- n9, err9 := m.RollbackRequest.MarshalTo(dAtA[i:])
- if err9 != nil {
- return 0, err9
+ if m.GetStatusRequest != nil {
+ {
+ size, err := m.GetStatusRequest.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- i += n9
+ i--
+ dAtA[i] = 0x52
}
if m.PrepareRequest != nil {
- dAtA[i] = 0x4a
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.PrepareRequest.Size()))
- n10, err10 := m.PrepareRequest.MarshalTo(dAtA[i:])
- if err10 != nil {
- return 0, err10
+ {
+ size, err := m.PrepareRequest.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- i += n10
+ i--
+ dAtA[i] = 0x4a
}
- if m.GetStatusRequest != nil {
- dAtA[i] = 0x52
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.GetStatusRequest.Size()))
- n11, err11 := m.GetStatusRequest.MarshalTo(dAtA[i:])
- if err11 != nil {
- return 0, err11
+ if m.RollbackRequest != nil {
+ {
+ size, err := m.RollbackRequest.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- i += n11
+ i--
+ dAtA[i] = 0x42
}
- if m.CommitDNShardRequest != nil {
- dAtA[i] = 0x5a
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.CommitDNShardRequest.Size()))
- n12, err12 := m.CommitDNShardRequest.MarshalTo(dAtA[i:])
- if err12 != nil {
- return 0, err12
+ if m.CommitRequest != nil {
+ {
+ size, err := m.CommitRequest.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- i += n12
+ i--
+ dAtA[i] = 0x3a
}
- if m.RollbackDNShardRequest != nil {
- dAtA[i] = 0x62
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.RollbackDNShardRequest.Size()))
- n13, err13 := m.RollbackDNShardRequest.MarshalTo(dAtA[i:])
- if err13 != nil {
- return 0, err13
+ if m.CNRequest != nil {
+ {
+ size, err := m.CNRequest.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- i += n13
+ i--
+ dAtA[i] = 0x32
}
- if m.RemoveMetadata != nil {
- dAtA[i] = 0x6a
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.RemoveMetadata.Size()))
- n14, err14 := m.RemoveMetadata.MarshalTo(dAtA[i:])
- if err14 != nil {
- return 0, err14
+ if m.Flag != 0 {
+ i = encodeVarintTxn(dAtA, i, uint64(m.Flag))
+ i--
+ dAtA[i] = 0x28
+ }
+ if m.Method != 0 {
+ i = encodeVarintTxn(dAtA, i, uint64(m.Method))
+ i--
+ dAtA[i] = 0x20
+ }
+ {
+ size, err := m.Txn.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
}
- i += n14
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0x1a
+ if m.TimeoutAt != 0 {
+ i = encodeVarintTxn(dAtA, i, uint64(m.TimeoutAt))
+ i--
+ dAtA[i] = 0x10
}
- return i, nil
+ if m.RequestID != 0 {
+ i = encodeVarintTxn(dAtA, i, uint64(m.RequestID))
+ i--
+ dAtA[i] = 0x8
+ }
+ return len(dAtA) - i, nil
}
func (m *TxnResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -1956,135 +2019,161 @@ func (m *TxnResponse) Marshal() (dAtA []byte, err error) {
}
func (m *TxnResponse) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TxnResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.RequestID != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.RequestID))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- if m.Txn != nil {
- dAtA[i] = 0x12
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.Txn.Size()))
- n15, err15 := m.Txn.MarshalTo(dAtA[i:])
- if err15 != nil {
- return 0, err15
+ if m.RemoveMetadata != nil {
+ {
+ size, err := m.RemoveMetadata.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- i += n15
- }
- if m.Method != 0 {
- dAtA[i] = 0x18
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.Method))
+ i--
+ dAtA[i] = 0x6a
}
- if m.Flag != 0 {
- dAtA[i] = 0x20
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.Flag))
+ if m.RollbackDNShardResponse != nil {
+ {
+ size, err := m.RollbackDNShardResponse.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x62
}
- if m.TxnError != nil {
- dAtA[i] = 0x2a
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.TxnError.Size()))
- n16, err16 := m.TxnError.MarshalTo(dAtA[i:])
- if err16 != nil {
- return 0, err16
+ if m.CommitDNShardResponse != nil {
+ {
+ size, err := m.CommitDNShardResponse.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- i += n16
+ i--
+ dAtA[i] = 0x5a
}
- if m.CNOpResponse != nil {
- dAtA[i] = 0x32
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.CNOpResponse.Size()))
- n17, err17 := m.CNOpResponse.MarshalTo(dAtA[i:])
- if err17 != nil {
- return 0, err17
+ if m.GetStatusResponse != nil {
+ {
+ size, err := m.GetStatusResponse.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- i += n17
+ i--
+ dAtA[i] = 0x52
}
- if m.CommitResponse != nil {
- dAtA[i] = 0x3a
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.CommitResponse.Size()))
- n18, err18 := m.CommitResponse.MarshalTo(dAtA[i:])
- if err18 != nil {
- return 0, err18
+ if m.PrepareResponse != nil {
+ {
+ size, err := m.PrepareResponse.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- i += n18
+ i--
+ dAtA[i] = 0x4a
}
if m.RollbackResponse != nil {
- dAtA[i] = 0x42
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.RollbackResponse.Size()))
- n19, err19 := m.RollbackResponse.MarshalTo(dAtA[i:])
- if err19 != nil {
- return 0, err19
+ {
+ size, err := m.RollbackResponse.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- i += n19
+ i--
+ dAtA[i] = 0x42
}
- if m.PrepareResponse != nil {
- dAtA[i] = 0x4a
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.PrepareResponse.Size()))
- n20, err20 := m.PrepareResponse.MarshalTo(dAtA[i:])
- if err20 != nil {
- return 0, err20
+ if m.CommitResponse != nil {
+ {
+ size, err := m.CommitResponse.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- i += n20
+ i--
+ dAtA[i] = 0x3a
}
- if m.GetStatusResponse != nil {
- dAtA[i] = 0x52
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.GetStatusResponse.Size()))
- n21, err21 := m.GetStatusResponse.MarshalTo(dAtA[i:])
- if err21 != nil {
- return 0, err21
+ if m.CNOpResponse != nil {
+ {
+ size, err := m.CNOpResponse.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- i += n21
+ i--
+ dAtA[i] = 0x32
}
- if m.CommitDNShardResponse != nil {
- dAtA[i] = 0x5a
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.CommitDNShardResponse.Size()))
- n22, err22 := m.CommitDNShardResponse.MarshalTo(dAtA[i:])
- if err22 != nil {
- return 0, err22
+ if m.TxnError != nil {
+ {
+ size, err := m.TxnError.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- i += n22
+ i--
+ dAtA[i] = 0x2a
}
- if m.RollbackDNShardResponse != nil {
- dAtA[i] = 0x62
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.RollbackDNShardResponse.Size()))
- n23, err23 := m.RollbackDNShardResponse.MarshalTo(dAtA[i:])
- if err23 != nil {
- return 0, err23
- }
- i += n23
+ if m.Flag != 0 {
+ i = encodeVarintTxn(dAtA, i, uint64(m.Flag))
+ i--
+ dAtA[i] = 0x20
}
- if m.RemoveMetadata != nil {
- dAtA[i] = 0x6a
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.RemoveMetadata.Size()))
- n24, err24 := m.RemoveMetadata.MarshalTo(dAtA[i:])
- if err24 != nil {
- return 0, err24
+ if m.Method != 0 {
+ i = encodeVarintTxn(dAtA, i, uint64(m.Method))
+ i--
+ dAtA[i] = 0x18
+ }
+ if m.Txn != nil {
+ {
+ size, err := m.Txn.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- i += n24
+ i--
+ dAtA[i] = 0x12
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.RequestID != 0 {
+ i = encodeVarintTxn(dAtA, i, uint64(m.RequestID))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TxnCommitRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -2092,30 +2181,36 @@ func (m *TxnCommitRequest) Marshal() (dAtA []byte, err error) {
}
func (m *TxnCommitRequest) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TxnCommitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
if m.Disable1PCOpt {
- dAtA[i] = 0x10
- i++
+ i--
if m.Disable1PCOpt {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
- i++
- }
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i--
+ dAtA[i] = 0x10
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TxnCommitResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -2123,20 +2218,26 @@ func (m *TxnCommitResponse) Marshal() (dAtA []byte, err error) {
}
func (m *TxnCommitResponse) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TxnCommitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TxnRollbackRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -2144,20 +2245,26 @@ func (m *TxnRollbackRequest) Marshal() (dAtA []byte, err error) {
}
func (m *TxnRollbackRequest) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TxnRollbackRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TxnRollbackResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -2165,20 +2272,26 @@ func (m *TxnRollbackResponse) Marshal() (dAtA []byte, err error) {
}
func (m *TxnRollbackResponse) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TxnRollbackResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TxnPrepareRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -2186,28 +2299,36 @@ func (m *TxnPrepareRequest) Marshal() (dAtA []byte, err error) {
}
func (m *TxnPrepareRequest) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TxnPrepareRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- dAtA[i] = 0xa
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.DNShard.Size()))
- n25, err25 := m.DNShard.MarshalTo(dAtA[i:])
- if err25 != nil {
- return 0, err25
- }
- i += n25
if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
+ {
+ size, err := m.DNShard.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- return i, nil
+ i--
+ dAtA[i] = 0xa
+ return len(dAtA) - i, nil
}
func (m *TxnPrepareResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -2215,20 +2336,26 @@ func (m *TxnPrepareResponse) Marshal() (dAtA []byte, err error) {
}
func (m *TxnPrepareResponse) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TxnPrepareResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TxnGetStatusRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -2236,28 +2363,36 @@ func (m *TxnGetStatusRequest) Marshal() (dAtA []byte, err error) {
}
func (m *TxnGetStatusRequest) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TxnGetStatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- dAtA[i] = 0xa
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.DNShard.Size()))
- n26, err26 := m.DNShard.MarshalTo(dAtA[i:])
- if err26 != nil {
- return 0, err26
- }
- i += n26
if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- return i, nil
+ {
+ size, err := m.DNShard.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0xa
+ return len(dAtA) - i, nil
}
func (m *TxnGetStatusResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -2265,20 +2400,26 @@ func (m *TxnGetStatusResponse) Marshal() (dAtA []byte, err error) {
}
func (m *TxnGetStatusResponse) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TxnGetStatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TxnCommitDNShardRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -2286,28 +2427,36 @@ func (m *TxnCommitDNShardRequest) Marshal() (dAtA []byte, err error) {
}
func (m *TxnCommitDNShardRequest) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TxnCommitDNShardRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- dAtA[i] = 0xa
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.DNShard.Size()))
- n27, err27 := m.DNShard.MarshalTo(dAtA[i:])
- if err27 != nil {
- return 0, err27
- }
- i += n27
if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- return i, nil
+ {
+ size, err := m.DNShard.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0xa
+ return len(dAtA) - i, nil
}
func (m *TxnCommitDNShardResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -2315,20 +2464,26 @@ func (m *TxnCommitDNShardResponse) Marshal() (dAtA []byte, err error) {
}
func (m *TxnCommitDNShardResponse) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TxnCommitDNShardResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TxnRollbackDNShardRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -2336,28 +2491,36 @@ func (m *TxnRollbackDNShardRequest) Marshal() (dAtA []byte, err error) {
}
func (m *TxnRollbackDNShardRequest) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TxnRollbackDNShardRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- dAtA[i] = 0xa
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.DNShard.Size()))
- n28, err28 := m.DNShard.MarshalTo(dAtA[i:])
- if err28 != nil {
- return 0, err28
- }
- i += n28
if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- return i, nil
+ {
+ size, err := m.DNShard.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0xa
+ return len(dAtA) - i, nil
}
func (m *TxnRollbackDNShardResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -2365,20 +2528,26 @@ func (m *TxnRollbackDNShardResponse) Marshal() (dAtA []byte, err error) {
}
func (m *TxnRollbackDNShardResponse) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TxnRollbackDNShardResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TxnRemoveMetadataRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -2386,28 +2555,36 @@ func (m *TxnRemoveMetadataRequest) Marshal() (dAtA []byte, err error) {
}
func (m *TxnRemoveMetadataRequest) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TxnRemoveMetadataRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- dAtA[i] = 0xa
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.DNShard.Size()))
- n29, err29 := m.DNShard.MarshalTo(dAtA[i:])
- if err29 != nil {
- return 0, err29
- }
- i += n29
if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
+ }
+ {
+ size, err := m.DNShard.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTxn(dAtA, i, uint64(size))
}
- return i, nil
+ i--
+ dAtA[i] = 0xa
+ return len(dAtA) - i, nil
}
func (m *TxnRemoveMetadataResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -2415,20 +2592,26 @@ func (m *TxnRemoveMetadataResponse) Marshal() (dAtA []byte, err error) {
}
func (m *TxnRemoveMetadataResponse) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TxnRemoveMetadataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
- return i, nil
+ return len(dAtA) - i, nil
}
func (m *TxnError) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
- n, err := m.MarshalTo(dAtA)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
@@ -2436,35 +2619,44 @@ func (m *TxnError) Marshal() (dAtA []byte, err error) {
}
func (m *TxnError) MarshalTo(dAtA []byte) (int, error) {
- var i int
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TxnError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
_ = i
var l int
_ = l
- if m.Code != 0 {
- dAtA[i] = 0x8
- i++
- i = encodeVarintTxn(dAtA, i, uint64(m.Code))
+ if m.XXX_unrecognized != nil {
+ i -= len(m.XXX_unrecognized)
+ copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Message) > 0 {
- dAtA[i] = 0x12
- i++
+ i -= len(m.Message)
+ copy(dAtA[i:], m.Message)
i = encodeVarintTxn(dAtA, i, uint64(len(m.Message)))
- i += copy(dAtA[i:], m.Message)
+ i--
+ dAtA[i] = 0x12
}
- if m.XXX_unrecognized != nil {
- i += copy(dAtA[i:], m.XXX_unrecognized)
+ if m.Code != 0 {
+ i = encodeVarintTxn(dAtA, i, uint64(m.Code))
+ i--
+ dAtA[i] = 0x8
}
- return i, nil
+ return len(dAtA) - i, nil
}
func encodeVarintTxn(dAtA []byte, offset int, v uint64) int {
+ offset -= sovTxn(v)
+ base := offset
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
- return offset + 1
+ return base
}
func (m *TxnMeta) Size() (n int) {
if m == nil {
@@ -3103,10 +3295,7 @@ func (m *TxnMeta) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthTxn
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTxn
}
if (iNdEx + skippy) > l {
@@ -3250,10 +3439,7 @@ func (m *CNTxnSnapshot) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthTxn
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTxn
}
if (iNdEx + skippy) > l {
@@ -3390,10 +3576,7 @@ func (m *CNOpRequest) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthTxn
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTxn
}
if (iNdEx + skippy) > l {
@@ -3478,10 +3661,7 @@ func (m *CNOpResponse) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthTxn
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTxn
}
if (iNdEx + skippy) > l {
@@ -3929,10 +4109,7 @@ func (m *TxnRequest) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthTxn
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTxn
}
if (iNdEx + skippy) > l {
@@ -4400,10 +4577,7 @@ func (m *TxnResponse) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthTxn
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTxn
}
if (iNdEx + skippy) > l {
@@ -4474,10 +4648,7 @@ func (m *TxnCommitRequest) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthTxn
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTxn
}
if (iNdEx + skippy) > l {
@@ -4528,10 +4699,7 @@ func (m *TxnCommitResponse) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthTxn
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTxn
}
if (iNdEx + skippy) > l {
@@ -4582,10 +4750,7 @@ func (m *TxnRollbackRequest) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthTxn
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTxn
}
if (iNdEx + skippy) > l {
@@ -4636,10 +4801,7 @@ func (m *TxnRollbackResponse) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthTxn
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTxn
}
if (iNdEx + skippy) > l {
@@ -4723,10 +4885,7 @@ func (m *TxnPrepareRequest) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthTxn
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTxn
}
if (iNdEx + skippy) > l {
@@ -4777,10 +4936,7 @@ func (m *TxnPrepareResponse) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthTxn
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTxn
}
if (iNdEx + skippy) > l {
@@ -4864,10 +5020,7 @@ func (m *TxnGetStatusRequest) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthTxn
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTxn
}
if (iNdEx + skippy) > l {
@@ -4918,10 +5071,7 @@ func (m *TxnGetStatusResponse) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthTxn
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTxn
}
if (iNdEx + skippy) > l {
@@ -5005,10 +5155,7 @@ func (m *TxnCommitDNShardRequest) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthTxn
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTxn
}
if (iNdEx + skippy) > l {
@@ -5059,10 +5206,7 @@ func (m *TxnCommitDNShardResponse) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthTxn
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTxn
}
if (iNdEx + skippy) > l {
@@ -5146,10 +5290,7 @@ func (m *TxnRollbackDNShardRequest) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthTxn
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTxn
}
if (iNdEx + skippy) > l {
@@ -5200,10 +5341,7 @@ func (m *TxnRollbackDNShardResponse) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthTxn
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTxn
}
if (iNdEx + skippy) > l {
@@ -5287,10 +5425,7 @@ func (m *TxnRemoveMetadataRequest) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthTxn
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTxn
}
if (iNdEx + skippy) > l {
@@ -5341,10 +5476,7 @@ func (m *TxnRemoveMetadataResponse) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthTxn
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTxn
}
if (iNdEx + skippy) > l {
@@ -5446,10 +5578,7 @@ func (m *TxnError) Unmarshal(dAtA []byte) error {
if err != nil {
return err
}
- if skippy < 0 {
- return ErrInvalidLengthTxn
- }
- if (iNdEx + skippy) < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthTxn
}
if (iNdEx + skippy) > l {
@@ -5468,6 +5597,7 @@ func (m *TxnError) Unmarshal(dAtA []byte) error {
func skipTxn(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
+ depth := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
@@ -5499,10 +5629,8 @@ func skipTxn(dAtA []byte) (n int, err error) {
break
}
}
- return iNdEx, nil
case 1:
iNdEx += 8
- return iNdEx, nil
case 2:
var length int
for shift := uint(0); ; shift += 7 {
@@ -5523,55 +5651,30 @@ func skipTxn(dAtA []byte) (n int, err error) {
return 0, ErrInvalidLengthTxn
}
iNdEx += length
- if iNdEx < 0 {
- return 0, ErrInvalidLengthTxn
- }
- return iNdEx, nil
case 3:
- for {
- var innerWire uint64
- var start int = iNdEx
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return 0, ErrIntOverflowTxn
- }
- if iNdEx >= l {
- return 0, io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- innerWire |= (uint64(b) & 0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- innerWireType := int(innerWire & 0x7)
- if innerWireType == 4 {
- break
- }
- next, err := skipTxn(dAtA[start:])
- if err != nil {
- return 0, err
- }
- iNdEx = start + next
- if iNdEx < 0 {
- return 0, ErrInvalidLengthTxn
- }
- }
- return iNdEx, nil
+ depth++
case 4:
- return iNdEx, nil
+ if depth == 0 {
+ return 0, ErrUnexpectedEndOfGroupTxn
+ }
+ depth--
case 5:
iNdEx += 4
- return iNdEx, nil
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
+ if iNdEx < 0 {
+ return 0, ErrInvalidLengthTxn
+ }
+ if depth == 0 {
+ return iNdEx, nil
+ }
}
- panic("unreachable")
+ return 0, io.ErrUnexpectedEOF
}
var (
- ErrInvalidLengthTxn = fmt.Errorf("proto: negative length found during unmarshaling")
- ErrIntOverflowTxn = fmt.Errorf("proto: integer overflow")
+ ErrInvalidLengthTxn = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowTxn = fmt.Errorf("proto: integer overflow")
+ ErrUnexpectedEndOfGroupTxn = fmt.Errorf("proto: unexpected end of group")
)
diff --git a/pkg/txn/clock/hlc.go b/pkg/txn/clock/hlc.go
index d74a14e9aff86adf1c54689a7d653a53ff338dd5..96bbfc29790169188fe287c21d7ede923c22bf50 100644
--- a/pkg/txn/clock/hlc.go
+++ b/pkg/txn/clock/hlc.go
@@ -6,6 +6,7 @@ import (
"sync"
"time"
+ "github.com/matrixorigin/matrixone/pkg/common/stopper"
"github.com/matrixorigin/matrixone/pkg/pb/timestamp"
)
@@ -89,6 +90,19 @@ func NewUnixNanoHLCClock(ctx context.Context, maxOffset time.Duration) *HLCClock
return clock
}
+// NewUnixNanoHLCClockWithStopper is similar to NewUnixNanoHLCClock, but perform
+// clock check use stopper
+func NewUnixNanoHLCClockWithStopper(stopper *stopper.Stopper, maxOffset time.Duration) *HLCClock {
+ clock := &HLCClock{
+ physicalClock: physicalClock,
+ maxOffset: maxOffset,
+ }
+ if err := stopper.RunTask(clock.offsetMonitor); err != nil {
+ panic(err)
+ }
+ return clock
+}
+
// HasNetworkLatency returns a boolean value indicating whether there is network
// latency involved when retrieving timestamps. There is no such network latency
// in HLCClock.
diff --git a/pkg/txn/service/service.go b/pkg/txn/service/service.go
index 92197b6bb7ed4314f6d1597aece408adaa53abc8..0b9b10a13eb4d64b32cdc91bd855a41fcf2a3fa8 100644
--- a/pkg/txn/service/service.go
+++ b/pkg/txn/service/service.go
@@ -31,6 +31,7 @@ import (
"github.com/matrixorigin/matrixone/pkg/txn/rpc"
"github.com/matrixorigin/matrixone/pkg/txn/storage"
"github.com/matrixorigin/matrixone/pkg/txn/util"
+ "go.uber.org/multierr"
"go.uber.org/zap"
)
@@ -108,6 +109,9 @@ func (s *service) Start() error {
func (s *service) Close() error {
s.waitRecoveryCompleted()
s.stopper.Stop()
+ if err := s.storage.Close(); err != nil {
+ return multierr.Append(err, s.sender.Close())
+ }
return s.sender.Close()
}
diff --git a/pkg/txn/storage/mem/kv_txn_storage.go b/pkg/txn/storage/mem/kv_txn_storage.go
index 4d72c6a890cd5ad0377fcbdd6f9c65c7fa8ea375..a7840cf054e6a264a8037b096eb7f6ed428ae689 100644
--- a/pkg/txn/storage/mem/kv_txn_storage.go
+++ b/pkg/txn/storage/mem/kv_txn_storage.go
@@ -183,6 +183,10 @@ func (kv *KVTxnStorage) StartRecovery(c chan txn.TxnMeta) {
}
}
+func (kv *KVTxnStorage) Close() error {
+ return nil
+}
+
func (kv *KVTxnStorage) GetLatestLsn() logservice.Lsn {
return kv.latest
}
diff --git a/pkg/txn/storage/types.go b/pkg/txn/storage/types.go
index 8f6d2e98cc3d9073dd8592e512131486a6c2358b..33248bbb81d140fa410c429ff5ffb5f9b32bd9f0 100644
--- a/pkg/txn/storage/types.go
+++ b/pkg/txn/storage/types.go
@@ -34,6 +34,8 @@ type TxnStorage interface {
// StartRecovery start txnStorage recovery process. Use the incoming channel to send the Txn that needs to be
// recovered and close the channel when all the logs have been processed.
StartRecovery(chan txn.TxnMeta)
+ // Close close the txn storage
+ Close() error
// Read execute read requests sent by CN.
//
diff --git a/proto/metadata.proto b/proto/metadata.proto
index 0873f16d9d9102c0ae549e31f46542d8637d9257..b9a5d73a683f87ecdf4085f8b21277e6e5c7cdb8 100644
--- a/proto/metadata.proto
+++ b/proto/metadata.proto
@@ -50,3 +50,11 @@ message LogShardRecord {
// Name is the human readable name of the shard given by the DN.
string Name = 3;
};
+
+// DNStore DN store metadata
+message DNStore {
+ // UUID DNStore uuid id
+ string UUID = 1;
+ // Shards DNShards
+ repeated DNShard Shards = 2 [(gogoproto.nullable) = false];
+}
\ No newline at end of file