github.com/matrixorigin/matrixone@v1.2.0/pkg/vm/engine/tae/db/operations.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: operations.proto

package db

import (
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"
	time "time"

	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
var _ = time.Kitchen

// This is a compile-time assertion to ensure that this generated file
// 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.GoGoProtoPackageIsVersion3 // please upgrade the proto package

func (m *AccessInfo) Reset()         { *m = AccessInfo{} }
func (m *AccessInfo) String() string { return proto.CompactTextString(m) }
func (*AccessInfo) ProtoMessage()    {}
func (*AccessInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b4a5877375e491e, []int{0}
}
func (m *AccessInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AccessInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AccessInfo.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 *AccessInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AccessInfo.Merge(m, src)
}
func (m *AccessInfo) XXX_Size() int {
	return m.ProtoSize()
}
func (m *AccessInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_AccessInfo.DiscardUnknown(m)
}

var xxx_messageInfo_AccessInfo proto.InternalMessageInfo

func (m *AccessInfo) GetAccountID() uint32 {
	if m != nil {
		return m.AccountID
	}
	return 0
}

func (m *AccessInfo) GetUserID() uint32 {
	if m != nil {
		return m.UserID
	}
	return 0
}

func (m *AccessInfo) GetRoleID() uint32 {
	if m != nil {
		return m.RoleID
	}
	return 0
}

func (m *CreateDatabaseReq) Reset()         { *m = CreateDatabaseReq{} }
func (m *CreateDatabaseReq) String() string { return proto.CompactTextString(m) }
func (*CreateDatabaseReq) ProtoMessage()    {}
func (*CreateDatabaseReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b4a5877375e491e, []int{1}
}
func (m *CreateDatabaseReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateDatabaseReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateDatabaseReq.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 *CreateDatabaseReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateDatabaseReq.Merge(m, src)
}
func (m *CreateDatabaseReq) XXX_Size() int {
	return m.ProtoSize()
}
func (m *CreateDatabaseReq) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateDatabaseReq.DiscardUnknown(m)
}

var xxx_messageInfo_CreateDatabaseReq proto.InternalMessageInfo

func (m *CreateDatabaseReq) GetAccessInfo() AccessInfo {
	if m != nil {
		return m.AccessInfo
	}
	return AccessInfo{}
}

func (m *CreateDatabaseReq) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *CreateDatabaseReq) GetCreateSql() string {
	if m != nil {
		return m.CreateSql
	}
	return ""
}

func (m *CreateDatabaseReq) GetDatabaseId() uint64 {
	if m != nil {
		return m.DatabaseId
	}
	return 0
}

func (m *FlushTable) Reset()         { *m = FlushTable{} }
func (m *FlushTable) String() string { return proto.CompactTextString(m) }
func (*FlushTable) ProtoMessage()    {}
func (*FlushTable) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b4a5877375e491e, []int{2}
}
func (m *FlushTable) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FlushTable) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FlushTable.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 *FlushTable) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FlushTable.Merge(m, src)
}
func (m *FlushTable) XXX_Size() int {
	return m.ProtoSize()
}
func (m *FlushTable) XXX_DiscardUnknown() {
	xxx_messageInfo_FlushTable.DiscardUnknown(m)
}

var xxx_messageInfo_FlushTable proto.InternalMessageInfo

func (m *FlushTable) GetAccessInfo() AccessInfo {
	if m != nil {
		return m.AccessInfo
	}
	return AccessInfo{}
}

func (m *FlushTable) GetDatabaseID() uint64 {
	if m != nil {
		return m.DatabaseID
	}
	return 0
}

func (m *FlushTable) GetTableID() uint64 {
	if m != nil {
		return m.TableID
	}
	return 0
}

func (m *Checkpoint) Reset()         { *m = Checkpoint{} }
func (m *Checkpoint) String() string { return proto.CompactTextString(m) }
func (*Checkpoint) ProtoMessage()    {}
func (*Checkpoint) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b4a5877375e491e, []int{3}
}
func (m *Checkpoint) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Checkpoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Checkpoint.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 *Checkpoint) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Checkpoint.Merge(m, src)
}
func (m *Checkpoint) XXX_Size() int {
	return m.ProtoSize()
}
func (m *Checkpoint) XXX_DiscardUnknown() {
	xxx_messageInfo_Checkpoint.DiscardUnknown(m)
}

var xxx_messageInfo_Checkpoint proto.InternalMessageInfo

func (m *Checkpoint) GetFlushDuration() time.Duration {
	if m != nil {
		return m.FlushDuration
	}
	return 0
}

func (m *InterceptCommit) Reset()         { *m = InterceptCommit{} }
func (m *InterceptCommit) String() string { return proto.CompactTextString(m) }
func (*InterceptCommit) ProtoMessage()    {}
func (*InterceptCommit) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b4a5877375e491e, []int{4}
}
func (m *InterceptCommit) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InterceptCommit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InterceptCommit.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 *InterceptCommit) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InterceptCommit.Merge(m, src)
}
func (m *InterceptCommit) XXX_Size() int {
	return m.ProtoSize()
}
func (m *InterceptCommit) XXX_DiscardUnknown() {
	xxx_messageInfo_InterceptCommit.DiscardUnknown(m)
}

var xxx_messageInfo_InterceptCommit proto.InternalMessageInfo

func (m *InterceptCommit) GetTableName() string {
	if m != nil {
		return m.TableName
	}
	return ""
}

func (m *InspectTN) Reset()         { *m = InspectTN{} }
func (m *InspectTN) String() string { return proto.CompactTextString(m) }
func (*InspectTN) ProtoMessage()    {}
func (*InspectTN) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b4a5877375e491e, []int{5}
}
func (m *InspectTN) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InspectTN) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InspectTN.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 *InspectTN) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InspectTN.Merge(m, src)
}
func (m *InspectTN) XXX_Size() int {
	return m.ProtoSize()
}
func (m *InspectTN) XXX_DiscardUnknown() {
	xxx_messageInfo_InspectTN.DiscardUnknown(m)
}

var xxx_messageInfo_InspectTN proto.InternalMessageInfo

func (m *InspectTN) GetAccessInfo() AccessInfo {
	if m != nil {
		return m.AccessInfo
	}
	return AccessInfo{}
}

func (m *InspectTN) GetOperation() string {
	if m != nil {
		return m.Operation
	}
	return ""
}

func (m *InspectResp) Reset()         { *m = InspectResp{} }
func (m *InspectResp) String() string { return proto.CompactTextString(m) }
func (*InspectResp) ProtoMessage()    {}
func (*InspectResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b4a5877375e491e, []int{6}
}
func (m *InspectResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InspectResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InspectResp.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 *InspectResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InspectResp.Merge(m, src)
}
func (m *InspectResp) XXX_Size() int {
	return m.ProtoSize()
}
func (m *InspectResp) XXX_DiscardUnknown() {
	xxx_messageInfo_InspectResp.DiscardUnknown(m)
}

var xxx_messageInfo_InspectResp proto.InternalMessageInfo

func (m *InspectResp) GetTyp() int {
	if m != nil {
		return m.Typ
	}
	return 0
}

func (m *InspectResp) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *InspectResp) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *CatalogResp) Reset()         { *m = CatalogResp{} }
func (m *CatalogResp) String() string { return proto.CompactTextString(m) }
func (*CatalogResp) ProtoMessage()    {}
func (*CatalogResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b4a5877375e491e, []int{7}
}
func (m *CatalogResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CatalogResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CatalogResp.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 *CatalogResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CatalogResp.Merge(m, src)
}
func (m *CatalogResp) XXX_Size() int {
	return m.ProtoSize()
}
func (m *CatalogResp) XXX_DiscardUnknown() {
	xxx_messageInfo_CatalogResp.DiscardUnknown(m)
}

var xxx_messageInfo_CatalogResp proto.InternalMessageInfo

func (m *CatalogResp) GetItem() string {
	if m != nil {
		return m.Item
	}
	return ""
}

func (m *CatalogResp) GetSub() []*CatalogResp {
	if m != nil {
		return m.Sub
	}
	return nil
}

func (m *FaultPoint) Reset()         { *m = FaultPoint{} }
func (m *FaultPoint) String() string { return proto.CompactTextString(m) }
func (*FaultPoint) ProtoMessage()    {}
func (*FaultPoint) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b4a5877375e491e, []int{8}
}
func (m *FaultPoint) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FaultPoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FaultPoint.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 *FaultPoint) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FaultPoint.Merge(m, src)
}
func (m *FaultPoint) XXX_Size() int {
	return m.ProtoSize()
}
func (m *FaultPoint) XXX_DiscardUnknown() {
	xxx_messageInfo_FaultPoint.DiscardUnknown(m)
}

var xxx_messageInfo_FaultPoint proto.InternalMessageInfo

func (m *FaultPoint) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *FaultPoint) GetFreq() string {
	if m != nil {
		return m.Freq
	}
	return ""
}

func (m *FaultPoint) GetAction() string {
	if m != nil {
		return m.Action
	}
	return ""
}

func (m *FaultPoint) GetIarg() int64 {
	if m != nil {
		return m.Iarg
	}
	return 0
}

func (m *FaultPoint) GetSarg() string {
	if m != nil {
		return m.Sarg
	}
	return ""
}

func (m *TraceSpan) Reset()         { *m = TraceSpan{} }
func (m *TraceSpan) String() string { return proto.CompactTextString(m) }
func (*TraceSpan) ProtoMessage()    {}
func (*TraceSpan) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b4a5877375e491e, []int{9}
}
func (m *TraceSpan) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TraceSpan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TraceSpan.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 *TraceSpan) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TraceSpan.Merge(m, src)
}
func (m *TraceSpan) XXX_Size() int {
	return m.ProtoSize()
}
func (m *TraceSpan) XXX_DiscardUnknown() {
	xxx_messageInfo_TraceSpan.DiscardUnknown(m)
}

var xxx_messageInfo_TraceSpan proto.InternalMessageInfo

func (m *TraceSpan) GetCmd() string {
	if m != nil {
		return m.Cmd
	}
	return ""
}

func (m *TraceSpan) GetSpans() string {
	if m != nil {
		return m.Spans
	}
	return ""
}

func (m *TraceSpan) GetThreshold() int64 {
	if m != nil {
		return m.Threshold
	}
	return 0
}

func (m *BlockMetaInfo) Reset()         { *m = BlockMetaInfo{} }
func (m *BlockMetaInfo) String() string { return proto.CompactTextString(m) }
func (*BlockMetaInfo) ProtoMessage()    {}
func (*BlockMetaInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b4a5877375e491e, []int{10}
}
func (m *BlockMetaInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BlockMetaInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BlockMetaInfo.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 *BlockMetaInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockMetaInfo.Merge(m, src)
}
func (m *BlockMetaInfo) XXX_Size() int {
	return m.ProtoSize()
}
func (m *BlockMetaInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockMetaInfo.DiscardUnknown(m)
}

var xxx_messageInfo_BlockMetaInfo proto.InternalMessageInfo

func (m *BlockMetaInfo) GetInfo() []uint64 {
	if m != nil {
		return m.Info
	}
	return nil
}

func (m *CkpMetaInfo) Reset()         { *m = CkpMetaInfo{} }
func (m *CkpMetaInfo) String() string { return proto.CompactTextString(m) }
func (*CkpMetaInfo) ProtoMessage()    {}
func (*CkpMetaInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b4a5877375e491e, []int{11}
}
func (m *CkpMetaInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CkpMetaInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CkpMetaInfo.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 *CkpMetaInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CkpMetaInfo.Merge(m, src)
}
func (m *CkpMetaInfo) XXX_Size() int {
	return m.ProtoSize()
}
func (m *CkpMetaInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_CkpMetaInfo.DiscardUnknown(m)
}

var xxx_messageInfo_CkpMetaInfo proto.InternalMessageInfo

func (m *CkpMetaInfo) GetVersion() uint32 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *CkpMetaInfo) GetLocation() []byte {
	if m != nil {
		return m.Location
	}
	return nil
}

func (m *StorageUsageResp_V0) Reset()         { *m = StorageUsageResp_V0{} }
func (m *StorageUsageResp_V0) String() string { return proto.CompactTextString(m) }
func (*StorageUsageResp_V0) ProtoMessage()    {}
func (*StorageUsageResp_V0) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b4a5877375e491e, []int{12}
}
func (m *StorageUsageResp_V0) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StorageUsageResp_V0) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StorageUsageResp_V0.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 *StorageUsageResp_V0) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StorageUsageResp_V0.Merge(m, src)
}
func (m *StorageUsageResp_V0) XXX_Size() int {
	return m.ProtoSize()
}
func (m *StorageUsageResp_V0) XXX_DiscardUnknown() {
	xxx_messageInfo_StorageUsageResp_V0.DiscardUnknown(m)
}

var xxx_messageInfo_StorageUsageResp_V0 proto.InternalMessageInfo

func (m *StorageUsageResp_V0) GetSucceed() bool {
	if m != nil {
		return m.Succeed
	}
	return false
}

func (m *StorageUsageResp_V0) GetCkpEntries() []*CkpMetaInfo {
	if m != nil {
		return m.CkpEntries
	}
	return nil
}

func (m *StorageUsageResp_V0) GetBlockEntries() []*BlockMetaInfo {
	if m != nil {
		return m.BlockEntries
	}
	return nil
}

func (m *StorageUsageReq) Reset()         { *m = StorageUsageReq{} }
func (m *StorageUsageReq) String() string { return proto.CompactTextString(m) }
func (*StorageUsageReq) ProtoMessage()    {}
func (*StorageUsageReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b4a5877375e491e, []int{13}
}
func (m *StorageUsageReq) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StorageUsageReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StorageUsageReq.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 *StorageUsageReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StorageUsageReq.Merge(m, src)
}
func (m *StorageUsageReq) XXX_Size() int {
	return m.ProtoSize()
}
func (m *StorageUsageReq) XXX_DiscardUnknown() {
	xxx_messageInfo_StorageUsageReq.DiscardUnknown(m)
}

var xxx_messageInfo_StorageUsageReq proto.InternalMessageInfo

func (m *StorageUsageReq) GetAccIds() []int32 {
	if m != nil {
		return m.AccIds
	}
	return nil
}

func (m *StorageUsageResp) Reset()         { *m = StorageUsageResp{} }
func (m *StorageUsageResp) String() string { return proto.CompactTextString(m) }
func (*StorageUsageResp) ProtoMessage()    {}
func (*StorageUsageResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_1b4a5877375e491e, []int{14}
}
func (m *StorageUsageResp) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StorageUsageResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StorageUsageResp.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 *StorageUsageResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StorageUsageResp.Merge(m, src)
}
func (m *StorageUsageResp) XXX_Size() int {
	return m.ProtoSize()
}
func (m *StorageUsageResp) XXX_DiscardUnknown() {
	xxx_messageInfo_StorageUsageResp.DiscardUnknown(m)
}

var xxx_messageInfo_StorageUsageResp proto.InternalMessageInfo

func (m *StorageUsageResp) GetSucceed() bool {
	if m != nil {
		return m.Succeed
	}
	return false
}

func (m *StorageUsageResp) GetAccIds() []int32 {
	if m != nil {
		return m.AccIds
	}
	return nil
}

func (m *StorageUsageResp) GetSizes() []uint64 {
	if m != nil {
		return m.Sizes
	}
	return nil
}

func (m *StorageUsageResp) GetMagic() uint64 {
	if m != nil {
		return m.Magic
	}
	return 0
}

func init() {
	proto.RegisterType((*AccessInfo)(nil), "db.AccessInfo")
	proto.RegisterType((*CreateDatabaseReq)(nil), "db.CreateDatabaseReq")
	proto.RegisterType((*FlushTable)(nil), "db.FlushTable")
	proto.RegisterType((*Checkpoint)(nil), "db.Checkpoint")
	proto.RegisterType((*InterceptCommit)(nil), "db.InterceptCommit")
	proto.RegisterType((*InspectTN)(nil), "db.InspectTN")
	proto.RegisterType((*InspectResp)(nil), "db.InspectResp")
	proto.RegisterType((*CatalogResp)(nil), "db.CatalogResp")
	proto.RegisterType((*FaultPoint)(nil), "db.FaultPoint")
	proto.RegisterType((*TraceSpan)(nil), "db.TraceSpan")
	proto.RegisterType((*BlockMetaInfo)(nil), "db.BlockMetaInfo")
	proto.RegisterType((*CkpMetaInfo)(nil), "db.CkpMetaInfo")
	proto.RegisterType((*StorageUsageResp_V0)(nil), "db.StorageUsageResp_V0")
	proto.RegisterType((*StorageUsageReq)(nil), "db.StorageUsageReq")
	proto.RegisterType((*StorageUsageResp)(nil), "db.StorageUsageResp")
}

func init() { proto.RegisterFile("operations.proto", fileDescriptor_1b4a5877375e491e) }

var fileDescriptor_1b4a5877375e491e = []byte{
	// 769 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x54, 0x4f, 0x6f, 0xe3, 0x44,
	0x14, 0x8f, 0x63, 0x67, 0xbb, 0x79, 0x69, 0x68, 0x3b, 0x20, 0x14, 0x56, 0x2b, 0x27, 0xec, 0x29,
	0x1c, 0x48, 0xd0, 0xc2, 0x0a, 0x89, 0x5b, 0x93, 0x50, 0xc9, 0xa0, 0x2e, 0xab, 0x49, 0x16, 0x8e,
	0x30, 0x9e, 0x4c, 0x1d, 0x2b, 0x8e, 0xc7, 0xf5, 0x8c, 0x2b, 0xb5, 0x47, 0x3e, 0x01, 0x5f, 0x00,
	0x89, 0x7e, 0x9b, 0x1e, 0x7b, 0xe4, 0x54, 0x41, 0xf3, 0x05, 0x38, 0xf7, 0x84, 0xe6, 0x8f, 0x6b,
	0x87, 0x03, 0x87, 0xde, 0xde, 0xef, 0x37, 0xf3, 0xde, 0xef, 0xbd, 0xdf, 0x1b, 0x1b, 0x0e, 0x79,
	0xc6, 0x72, 0x22, 0x63, 0x9e, 0x8a, 0x51, 0x96, 0x73, 0xc9, 0x51, 0x73, 0x19, 0xbe, 0xf8, 0x3c,
	0x8a, 0xe5, 0xaa, 0x08, 0x47, 0x94, 0x6f, 0xc6, 0x11, 0x8f, 0xf8, 0x58, 0x1f, 0x85, 0xc5, 0x99,
	0x46, 0x1a, 0xe8, 0xc8, 0xa4, 0xbc, 0xfa, 0x05, 0xe0, 0x98, 0x52, 0x26, 0x44, 0x90, 0x9e, 0x71,
	0xf4, 0x12, 0xda, 0xc7, 0x94, 0xf2, 0x22, 0x95, 0xc1, 0xac, 0xe7, 0x0c, 0x9c, 0x61, 0x17, 0x57,
	0x04, 0xfa, 0x18, 0x9e, 0xbd, 0x17, 0x2c, 0x0f, 0x66, 0xbd, 0xa6, 0x3e, 0xb2, 0x48, 0xf1, 0x98,
	0x27, 0x2c, 0x98, 0xf5, 0x5c, 0xc3, 0x1b, 0xf4, 0x8d, 0xf7, 0xcf, 0x75, 0xbf, 0xf1, 0xea, 0xda,
	0x81, 0xa3, 0x69, 0xce, 0x88, 0x64, 0x33, 0x22, 0x49, 0x48, 0x04, 0xc3, 0xec, 0x1c, 0x7d, 0x55,
	0xd7, 0xd5, 0x52, 0x9d, 0xd7, 0x1f, 0x8c, 0x96, 0xe1, 0xa8, 0x62, 0x27, 0xde, 0xcd, 0x5d, 0xbf,
	0x81, 0xeb, 0xfd, 0x21, 0xf0, 0x52, 0xb2, 0x61, 0x5a, 0xbf, 0x8d, 0x75, 0xac, 0x7a, 0x36, 0xe5,
	0xe7, 0xe7, 0x89, 0x6e, 0xa0, 0x8d, 0x2b, 0x02, 0xf9, 0x00, 0xa5, 0x6c, 0xb0, 0xec, 0x79, 0x03,
	0x67, 0xe8, 0xe1, 0x1a, 0x63, 0x7b, 0xfc, 0xd5, 0x01, 0x38, 0x49, 0x0a, 0xb1, 0x5a, 0x90, 0x30,
	0x61, 0x4f, 0x6c, 0xae, 0x2e, 0x65, 0x2c, 0xaa, 0x4b, 0xcd, 0x50, 0x0f, 0xf6, 0x74, 0x79, 0xeb,
	0x93, 0x87, 0x4b, 0x68, 0x9b, 0xf8, 0x1e, 0x60, 0xba, 0x62, 0x74, 0x9d, 0xf1, 0x38, 0x95, 0xe8,
	0x6b, 0xe8, 0xea, 0x8e, 0x66, 0x85, 0xd9, 0xb1, 0x6e, 0xc3, 0x9d, 0x1c, 0x3d, 0xdc, 0xf5, 0xbb,
	0x32, 0xde, 0xb0, 0x51, 0x79, 0x80, 0x77, 0xef, 0xd9, 0x62, 0x6f, 0xe0, 0x20, 0x48, 0x25, 0xcb,
	0x29, 0xcb, 0xe4, 0x94, 0x6f, 0x36, 0xb1, 0x54, 0x46, 0x69, 0xc1, 0xb7, 0xca, 0x41, 0xc7, 0x18,
	0xf5, 0x48, 0xd8, 0x34, 0x06, 0xed, 0x20, 0x15, 0x19, 0xa3, 0x72, 0xf1, 0xf6, 0x89, 0x36, 0xbc,
	0x84, 0xf6, 0x0f, 0xe5, 0xc3, 0xb4, 0x8b, 0xaa, 0x08, 0x2b, 0x13, 0x42, 0xc7, 0xca, 0x60, 0x26,
	0x32, 0xf4, 0x09, 0xb8, 0x8b, 0xcb, 0x4c, 0x2b, 0xb4, 0x26, 0x7b, 0x0f, 0x77, 0x7d, 0x37, 0x4e,
	0x25, 0x56, 0x9c, 0x32, 0xed, 0x94, 0x09, 0x41, 0xa2, 0x72, 0xe9, 0x25, 0x54, 0x27, 0xef, 0xc8,
	0x65, 0xc2, 0xc9, 0x52, 0xdb, 0xb9, 0x8f, 0x4b, 0x68, 0x35, 0xbe, 0x83, 0xce, 0x94, 0x48, 0x92,
	0xf0, 0x48, 0x6b, 0x20, 0xf0, 0x02, 0xc9, 0x36, 0x76, 0x70, 0x1d, 0xa3, 0x4f, 0xc1, 0x9d, 0x17,
	0x61, 0xaf, 0x39, 0x70, 0x87, 0x9d, 0xd7, 0x07, 0x6a, 0xb2, 0x5a, 0x06, 0x56, 0x67, 0xb6, 0xd6,
	0x15, 0xc0, 0x09, 0x29, 0x12, 0xf9, 0x4e, 0xaf, 0x06, 0x81, 0x57, 0xf3, 0x50, 0xc7, 0x8a, 0x3b,
	0xc9, 0xd9, 0x79, 0xf9, 0x32, 0x55, 0xac, 0xbe, 0x8b, 0x63, 0xaa, 0x6d, 0x30, 0xcf, 0xd2, 0x22,
	0xdd, 0x0a, 0xc9, 0x23, 0xfd, 0x1a, 0x5d, 0xac, 0x63, 0xc5, 0xcd, 0x15, 0xd7, 0x32, 0xf9, 0x2a,
	0xb6, 0xda, 0x3f, 0x41, 0x7b, 0x91, 0x13, 0xca, 0xe6, 0x19, 0x49, 0xd1, 0x21, 0xb8, 0x74, 0xb3,
	0xb4, 0xca, 0x2a, 0x44, 0x1f, 0x41, 0x4b, 0x64, 0x24, 0x15, 0x56, 0xd9, 0x00, 0xb5, 0x04, 0xb9,
	0xca, 0x99, 0x58, 0xf1, 0xc4, 0xd8, 0xe3, 0xe2, 0x8a, 0xb0, 0x85, 0x3f, 0x83, 0xee, 0x24, 0xe1,
	0x74, 0x7d, 0xca, 0x24, 0x29, 0xbf, 0xae, 0xd8, 0x6c, 0xda, 0x1d, 0x7a, 0x58, 0xc7, 0xf6, 0x6a,
	0x00, 0x9d, 0xe9, 0x3a, 0x7b, 0xbc, 0xd8, 0x83, 0xbd, 0x0b, 0x96, 0x8b, 0xf2, 0x55, 0x76, 0x71,
	0x09, 0xd1, 0x0b, 0x78, 0x9e, 0x70, 0x5a, 0xed, 0x7e, 0x1f, 0x3f, 0x62, 0x5b, 0xea, 0x77, 0x07,
	0x3e, 0x9c, 0x4b, 0x9e, 0x93, 0x88, 0xbd, 0x57, 0x7b, 0x54, 0x56, 0xff, 0xfc, 0xe3, 0x17, 0xaa,
	0xe6, 0xbc, 0xa0, 0x94, 0x31, 0x33, 0xdd, 0x73, 0x5c, 0x42, 0x34, 0x06, 0x98, 0xae, 0xb3, 0x6f,
	0x53, 0x99, 0xc7, 0x4c, 0xec, 0x2c, 0xab, 0x6a, 0x09, 0xd7, 0xae, 0xa0, 0x37, 0xb0, 0xaf, 0x07,
	0x2b, 0x53, 0x5c, 0x9d, 0x72, 0xa4, 0x52, 0x76, 0x06, 0xc6, 0x3b, 0xd7, 0x6c, 0x7f, 0x63, 0x38,
	0xd8, 0x6d, 0xcf, 0xee, 0x91, 0x06, 0x4b, 0xa1, 0x9d, 0x69, 0x61, 0x8b, 0x6c, 0xc2, 0x05, 0x1c,
	0xfe, 0x77, 0x9e, 0xff, 0x19, 0xa6, 0xaa, 0xd5, 0xac, 0xd7, 0x52, 0x6b, 0x9c, 0xc7, 0x57, 0xb6,
	0x59, 0x0f, 0x1b, 0xa0, 0xd8, 0x53, 0x12, 0xc5, 0xd4, 0xfe, 0xb8, 0x0c, 0x30, 0xba, 0x93, 0xc1,
	0xed, 0xdf, 0x7e, 0xe3, 0xe6, 0xde, 0x77, 0x6e, 0xef, 0x7d, 0xe7, 0xaf, 0x7b, 0xbf, 0xf1, 0xdb,
	0xd6, 0x6f, 0xfc, 0xb1, 0xf5, 0x9d, 0xdb, 0xad, 0xdf, 0xf8, 0x73, 0xeb, 0x37, 0xc2, 0x67, 0xfa,
	0x17, 0xff, 0xe5, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xe6, 0xfd, 0xae, 0xd5, 0x29, 0x06, 0x00,
	0x00,
}

func (m *AccessInfo) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AccessInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AccessInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RoleID != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.RoleID))
		i--
		dAtA[i] = 0x18
	}
	if m.UserID != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.UserID))
		i--
		dAtA[i] = 0x10
	}
	if m.AccountID != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.AccountID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *CreateDatabaseReq) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CreateDatabaseReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreateDatabaseReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DatabaseId != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.DatabaseId))
		i--
		dAtA[i] = 0x20
	}
	if len(m.CreateSql) > 0 {
		i -= len(m.CreateSql)
		copy(dAtA[i:], m.CreateSql)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.CreateSql)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.AccessInfo.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintOperations(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *FlushTable) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FlushTable) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FlushTable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TableID != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.TableID))
		i--
		dAtA[i] = 0x18
	}
	if m.DatabaseID != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.DatabaseID))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.AccessInfo.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintOperations(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *Checkpoint) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Checkpoint) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Checkpoint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FlushDuration != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.FlushDuration))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *InterceptCommit) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *InterceptCommit) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InterceptCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TableName) > 0 {
		i -= len(m.TableName)
		copy(dAtA[i:], m.TableName)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.TableName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *InspectTN) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *InspectTN) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InspectTN) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Operation) > 0 {
		i -= len(m.Operation)
		copy(dAtA[i:], m.Operation)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.Operation)))
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.AccessInfo.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintOperations(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *InspectResp) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *InspectResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InspectResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Payload) > 0 {
		i -= len(m.Payload)
		copy(dAtA[i:], m.Payload)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.Payload)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x12
	}
	if m.Typ != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.Typ))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *CatalogResp) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CatalogResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CatalogResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Sub) > 0 {
		for iNdEx := len(m.Sub) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Sub[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintOperations(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Item) > 0 {
		i -= len(m.Item)
		copy(dAtA[i:], m.Item)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.Item)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *FaultPoint) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FaultPoint) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FaultPoint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Sarg) > 0 {
		i -= len(m.Sarg)
		copy(dAtA[i:], m.Sarg)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.Sarg)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Iarg != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.Iarg))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Action) > 0 {
		i -= len(m.Action)
		copy(dAtA[i:], m.Action)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.Action)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Freq) > 0 {
		i -= len(m.Freq)
		copy(dAtA[i:], m.Freq)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.Freq)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TraceSpan) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TraceSpan) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TraceSpan) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Threshold != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.Threshold))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Spans) > 0 {
		i -= len(m.Spans)
		copy(dAtA[i:], m.Spans)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.Spans)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Cmd) > 0 {
		i -= len(m.Cmd)
		copy(dAtA[i:], m.Cmd)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.Cmd)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BlockMetaInfo) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BlockMetaInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockMetaInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Info) > 0 {
		dAtA5 := make([]byte, len(m.Info)*10)
		var j4 int
		for _, num := range m.Info {
			for num >= 1<<7 {
				dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j4++
			}
			dAtA5[j4] = uint8(num)
			j4++
		}
		i -= j4
		copy(dAtA[i:], dAtA5[:j4])
		i = encodeVarintOperations(dAtA, i, uint64(j4))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CkpMetaInfo) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CkpMetaInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CkpMetaInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Location) > 0 {
		i -= len(m.Location)
		copy(dAtA[i:], m.Location)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.Location)))
		i--
		dAtA[i] = 0x12
	}
	if m.Version != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.Version))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *StorageUsageResp_V0) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StorageUsageResp_V0) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StorageUsageResp_V0) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.BlockEntries) > 0 {
		for iNdEx := len(m.BlockEntries) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.BlockEntries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintOperations(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.CkpEntries) > 0 {
		for iNdEx := len(m.CkpEntries) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.CkpEntries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintOperations(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Succeed {
		i--
		if m.Succeed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *StorageUsageReq) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StorageUsageReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StorageUsageReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AccIds) > 0 {
		dAtA7 := make([]byte, len(m.AccIds)*10)
		var j6 int
		for _, num1 := range m.AccIds {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA7[j6] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j6++
			}
			dAtA7[j6] = uint8(num)
			j6++
		}
		i -= j6
		copy(dAtA[i:], dAtA7[:j6])
		i = encodeVarintOperations(dAtA, i, uint64(j6))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *StorageUsageResp) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StorageUsageResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StorageUsageResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Magic != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.Magic))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Sizes) > 0 {
		dAtA9 := make([]byte, len(m.Sizes)*10)
		var j8 int
		for _, num := range m.Sizes {
			for num >= 1<<7 {
				dAtA9[j8] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j8++
			}
			dAtA9[j8] = uint8(num)
			j8++
		}
		i -= j8
		copy(dAtA[i:], dAtA9[:j8])
		i = encodeVarintOperations(dAtA, i, uint64(j8))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.AccIds) > 0 {
		dAtA11 := make([]byte, len(m.AccIds)*10)
		var j10 int
		for _, num1 := range m.AccIds {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA11[j10] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j10++
			}
			dAtA11[j10] = uint8(num)
			j10++
		}
		i -= j10
		copy(dAtA[i:], dAtA11[:j10])
		i = encodeVarintOperations(dAtA, i, uint64(j10))
		i--
		dAtA[i] = 0x12
	}
	if m.Succeed {
		i--
		if m.Succeed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintOperations(dAtA []byte, offset int, v uint64) int {
	offset -= sovOperations(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *AccessInfo) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AccountID != 0 {
		n += 1 + sovOperations(uint64(m.AccountID))
	}
	if m.UserID != 0 {
		n += 1 + sovOperations(uint64(m.UserID))
	}
	if m.RoleID != 0 {
		n += 1 + sovOperations(uint64(m.RoleID))
	}
	return n
}

func (m *CreateDatabaseReq) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.AccessInfo.ProtoSize()
	n += 1 + l + sovOperations(uint64(l))
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	l = len(m.CreateSql)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	if m.DatabaseId != 0 {
		n += 1 + sovOperations(uint64(m.DatabaseId))
	}
	return n
}

func (m *FlushTable) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.AccessInfo.ProtoSize()
	n += 1 + l + sovOperations(uint64(l))
	if m.DatabaseID != 0 {
		n += 1 + sovOperations(uint64(m.DatabaseID))
	}
	if m.TableID != 0 {
		n += 1 + sovOperations(uint64(m.TableID))
	}
	return n
}

func (m *Checkpoint) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FlushDuration != 0 {
		n += 1 + sovOperations(uint64(m.FlushDuration))
	}
	return n
}

func (m *InterceptCommit) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TableName)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	return n
}

func (m *InspectTN) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.AccessInfo.ProtoSize()
	n += 1 + l + sovOperations(uint64(l))
	l = len(m.Operation)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	return n
}

func (m *InspectResp) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Typ != 0 {
		n += 1 + sovOperations(uint64(m.Typ))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	return n
}

func (m *CatalogResp) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Item)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	if len(m.Sub) > 0 {
		for _, e := range m.Sub {
			l = e.ProtoSize()
			n += 1 + l + sovOperations(uint64(l))
		}
	}
	return n
}

func (m *FaultPoint) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	l = len(m.Freq)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	l = len(m.Action)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	if m.Iarg != 0 {
		n += 1 + sovOperations(uint64(m.Iarg))
	}
	l = len(m.Sarg)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	return n
}

func (m *TraceSpan) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Cmd)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	l = len(m.Spans)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	if m.Threshold != 0 {
		n += 1 + sovOperations(uint64(m.Threshold))
	}
	return n
}

func (m *BlockMetaInfo) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Info) > 0 {
		l = 0
		for _, e := range m.Info {
			l += sovOperations(uint64(e))
		}
		n += 1 + sovOperations(uint64(l)) + l
	}
	return n
}

func (m *CkpMetaInfo) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Version != 0 {
		n += 1 + sovOperations(uint64(m.Version))
	}
	l = len(m.Location)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	return n
}

func (m *StorageUsageResp_V0) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Succeed {
		n += 2
	}
	if len(m.CkpEntries) > 0 {
		for _, e := range m.CkpEntries {
			l = e.ProtoSize()
			n += 1 + l + sovOperations(uint64(l))
		}
	}
	if len(m.BlockEntries) > 0 {
		for _, e := range m.BlockEntries {
			l = e.ProtoSize()
			n += 1 + l + sovOperations(uint64(l))
		}
	}
	return n
}

func (m *StorageUsageReq) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.AccIds) > 0 {
		l = 0
		for _, e := range m.AccIds {
			l += sovOperations(uint64(e))
		}
		n += 1 + sovOperations(uint64(l)) + l
	}
	return n
}

func (m *StorageUsageResp) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Succeed {
		n += 2
	}
	if len(m.AccIds) > 0 {
		l = 0
		for _, e := range m.AccIds {
			l += sovOperations(uint64(e))
		}
		n += 1 + sovOperations(uint64(l)) + l
	}
	if len(m.Sizes) > 0 {
		l = 0
		for _, e := range m.Sizes {
			l += sovOperations(uint64(e))
		}
		n += 1 + sovOperations(uint64(l)) + l
	}
	if m.Magic != 0 {
		n += 1 + sovOperations(uint64(m.Magic))
	}
	return n
}

func sovOperations(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozOperations(x uint64) (n int) {
	return sovOperations(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *AccessInfo) 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 ErrIntOverflowOperations
			}
			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: AccessInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AccessInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountID", wireType)
			}
			m.AccountID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AccountID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserID", wireType)
			}
			m.UserID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UserID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RoleID", wireType)
			}
			m.RoleID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RoleID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipOperations(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOperations
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CreateDatabaseReq) 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 ErrIntOverflowOperations
			}
			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: CreateDatabaseReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateDatabaseReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccessInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthOperations
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.AccessInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				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 ErrInvalidLengthOperations
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOperations
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateSql", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				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 ErrInvalidLengthOperations
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOperations
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CreateSql = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DatabaseId", wireType)
			}
			m.DatabaseId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DatabaseId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipOperations(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOperations
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FlushTable) 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 ErrIntOverflowOperations
			}
			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: FlushTable: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FlushTable: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccessInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthOperations
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.AccessInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DatabaseID", wireType)
			}
			m.DatabaseID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DatabaseID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableID", wireType)
			}
			m.TableID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TableID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipOperations(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOperations
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Checkpoint) 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 ErrIntOverflowOperations
			}
			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: Checkpoint: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Checkpoint: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FlushDuration", wireType)
			}
			m.FlushDuration = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FlushDuration |= time.Duration(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipOperations(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOperations
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InterceptCommit) 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 ErrIntOverflowOperations
			}
			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: InterceptCommit: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InterceptCommit: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				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 ErrInvalidLengthOperations
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOperations
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TableName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOperations(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOperations
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InspectTN) 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 ErrIntOverflowOperations
			}
			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: InspectTN: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InspectTN: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccessInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthOperations
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.AccessInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Operation", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				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 ErrInvalidLengthOperations
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOperations
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Operation = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOperations(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOperations
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InspectResp) 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 ErrIntOverflowOperations
			}
			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: InspectResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InspectResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Typ", wireType)
			}
			m.Typ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Typ |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				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 ErrInvalidLengthOperations
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOperations
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthOperations
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
			if m.Payload == nil {
				m.Payload = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOperations(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOperations
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CatalogResp) 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 ErrIntOverflowOperations
			}
			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: CatalogResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CatalogResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Item", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				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 ErrInvalidLengthOperations
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOperations
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Item = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sub", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthOperations
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sub = append(m.Sub, &CatalogResp{})
			if err := m.Sub[len(m.Sub)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOperations(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOperations
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FaultPoint) 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 ErrIntOverflowOperations
			}
			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: FaultPoint: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FaultPoint: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				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 ErrInvalidLengthOperations
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOperations
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Freq", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				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 ErrInvalidLengthOperations
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOperations
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Freq = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				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 ErrInvalidLengthOperations
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOperations
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Action = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Iarg", wireType)
			}
			m.Iarg = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Iarg |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sarg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				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 ErrInvalidLengthOperations
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOperations
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sarg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOperations(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOperations
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TraceSpan) 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 ErrIntOverflowOperations
			}
			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: TraceSpan: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TraceSpan: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cmd", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				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 ErrInvalidLengthOperations
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOperations
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cmd = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spans", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				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 ErrInvalidLengthOperations
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOperations
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Spans = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Threshold", wireType)
			}
			m.Threshold = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Threshold |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipOperations(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOperations
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockMetaInfo) 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 ErrIntOverflowOperations
			}
			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: BlockMetaInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockMetaInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowOperations
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Info = append(m.Info, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowOperations
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthOperations
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthOperations
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Info) == 0 {
					m.Info = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowOperations
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Info = append(m.Info, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipOperations(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOperations
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CkpMetaInfo) 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 ErrIntOverflowOperations
			}
			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: CkpMetaInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CkpMetaInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			m.Version = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Version |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Location", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthOperations
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Location = append(m.Location[:0], dAtA[iNdEx:postIndex]...)
			if m.Location == nil {
				m.Location = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOperations(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOperations
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StorageUsageResp_V0) 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 ErrIntOverflowOperations
			}
			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: StorageUsageResp_V0: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StorageUsageResp_V0: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Succeed", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Succeed = bool(v != 0)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CkpEntries", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthOperations
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CkpEntries = append(m.CkpEntries, &CkpMetaInfo{})
			if err := m.CkpEntries[len(m.CkpEntries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockEntries", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthOperations
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockEntries = append(m.BlockEntries, &BlockMetaInfo{})
			if err := m.BlockEntries[len(m.BlockEntries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOperations(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOperations
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StorageUsageReq) 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 ErrIntOverflowOperations
			}
			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: StorageUsageReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StorageUsageReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowOperations
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.AccIds = append(m.AccIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowOperations
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthOperations
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthOperations
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.AccIds) == 0 {
					m.AccIds = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowOperations
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.AccIds = append(m.AccIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field AccIds", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipOperations(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOperations
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StorageUsageResp) 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 ErrIntOverflowOperations
			}
			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: StorageUsageResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StorageUsageResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Succeed", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Succeed = bool(v != 0)
		case 2:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowOperations
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.AccIds = append(m.AccIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowOperations
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthOperations
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthOperations
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.AccIds) == 0 {
					m.AccIds = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowOperations
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.AccIds = append(m.AccIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field AccIds", wireType)
			}
		case 3:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowOperations
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Sizes = append(m.Sizes, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowOperations
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthOperations
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthOperations
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Sizes) == 0 {
					m.Sizes = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowOperations
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Sizes = append(m.Sizes, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Sizes", wireType)
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Magic", wireType)
			}
			m.Magic = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Magic |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipOperations(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOperations
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipOperations(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 {
			if shift >= 64 {
				return 0, ErrIntOverflowOperations
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthOperations
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupOperations
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthOperations
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthOperations        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowOperations          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupOperations = fmt.Errorf("proto: unexpected end of group")
)