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

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

package memoryengine

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

	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	plan "github.com/matrixorigin/matrixone/pkg/pb/plan"
	github_com_matrixorigin_matrixone_pkg_vm_engine "github.com/matrixorigin/matrixone/pkg/vm/engine"
)

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

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

var xxx_messageInfo_OpenDatabaseReq proto.InternalMessageInfo

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

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

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

var xxx_messageInfo_OpenDatabaseResp proto.InternalMessageInfo

func (m *OpenDatabaseResp) GetID() ID {
	if m != nil {
		return m.ID
	}
	return 0
}

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

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{3}
}
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) GetID() ID {
	if m != nil {
		return m.ID
	}
	return 0
}

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

var xxx_messageInfo_CreateDatabaseResp proto.InternalMessageInfo

func (m *CreateDatabaseResp) GetID() ID {
	if m != nil {
		return m.ID
	}
	return 0
}

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

var xxx_messageInfo_GetDatabasesReq proto.InternalMessageInfo

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

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

var xxx_messageInfo_GetDatabasesResp proto.InternalMessageInfo

func (m *GetDatabasesResp) GetNames() []string {
	if m != nil {
		return m.Names
	}
	return nil
}

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

var xxx_messageInfo_DeleteDatabaseReq proto.InternalMessageInfo

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

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

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

var xxx_messageInfo_DeleteDatabaseResp proto.InternalMessageInfo

func (m *DeleteDatabaseResp) GetID() ID {
	if m != nil {
		return m.ID
	}
	return 0
}

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

var xxx_messageInfo_OpenRelationReq proto.InternalMessageInfo

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

func (m *OpenRelationReq) GetDatabaseName() string {
	if m != nil {
		return m.DatabaseName
	}
	return ""
}

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

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

var xxx_messageInfo_OpenRelationResp proto.InternalMessageInfo

func (m *OpenRelationResp) GetID() ID {
	if m != nil {
		return m.ID
	}
	return 0
}

func (m *OpenRelationResp) GetType() RelationType {
	if m != nil {
		return m.Type
	}
	return 0
}

func (m *OpenRelationResp) GetDatabaseName() string {
	if m != nil {
		return m.DatabaseName
	}
	return ""
}

func (m *OpenRelationResp) GetRelationName() string {
	if m != nil {
		return m.RelationName
	}
	return ""
}

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

var xxx_messageInfo_CreateRelationReq proto.InternalMessageInfo

func (m *CreateRelationReq) GetID() ID {
	if m != nil {
		return m.ID
	}
	return 0
}

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

func (m *CreateRelationReq) GetDatabaseName() string {
	if m != nil {
		return m.DatabaseName
	}
	return ""
}

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

func (m *CreateRelationReq) GetType() RelationType {
	if m != nil {
		return m.Type
	}
	return 0
}

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

var xxx_messageInfo_CreateRelationResp proto.InternalMessageInfo

func (m *CreateRelationResp) GetID() ID {
	if m != nil {
		return m.ID
	}
	return 0
}

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

var xxx_messageInfo_GetRelationsReq proto.InternalMessageInfo

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

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

var xxx_messageInfo_GetRelationsResp proto.InternalMessageInfo

func (m *GetRelationsResp) GetNames() []string {
	if m != nil {
		return m.Names
	}
	return nil
}

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

var xxx_messageInfo_DeleteRelationReq proto.InternalMessageInfo

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

func (m *DeleteRelationReq) GetDatabaseName() string {
	if m != nil {
		return m.DatabaseName
	}
	return ""
}

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

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

var xxx_messageInfo_DeleteRelationResp proto.InternalMessageInfo

func (m *DeleteRelationResp) GetID() ID {
	if m != nil {
		return m.ID
	}
	return 0
}

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

var xxx_messageInfo_GetTableDefsReq proto.InternalMessageInfo

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

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

var xxx_messageInfo_GetTableDefsResp proto.InternalMessageInfo

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

var xxx_messageInfo_WriteResp proto.InternalMessageInfo

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

var xxx_messageInfo_NewTableIterReq proto.InternalMessageInfo

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

func (m *NewTableIterReq) GetExpr() *plan.Expr {
	if m != nil {
		return m.Expr
	}
	return nil
}

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

var xxx_messageInfo_NewTableIterResp proto.InternalMessageInfo

func (m *NewTableIterResp) GetIterID() ID {
	if m != nil {
		return m.IterID
	}
	return 0
}

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

var xxx_messageInfo_ReadReq proto.InternalMessageInfo

func (m *ReadReq) GetIterID() ID {
	if m != nil {
		return m.IterID
	}
	return 0
}

func (m *ReadReq) GetColNames() []string {
	if m != nil {
		return m.ColNames
	}
	return nil
}

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

var xxx_messageInfo_DeleteResp proto.InternalMessageInfo

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

var xxx_messageInfo_GetPrimaryKeysReq proto.InternalMessageInfo

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

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

var xxx_messageInfo_GetPrimaryKeysResp proto.InternalMessageInfo

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

var xxx_messageInfo_CloseTableIterReq proto.InternalMessageInfo

func (m *CloseTableIterReq) GetIterID() ID {
	if m != nil {
		return m.IterID
	}
	return 0
}

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

var xxx_messageInfo_CloseTableIterResp proto.InternalMessageInfo

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

var xxx_messageInfo_GetHiddenKeysReq proto.InternalMessageInfo

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

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

var xxx_messageInfo_GetHiddenKeysResp proto.InternalMessageInfo

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

var xxx_messageInfo_TableStatsReq proto.InternalMessageInfo

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

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

var xxx_messageInfo_TableStatsResp proto.InternalMessageInfo

func (m *TableStatsResp) GetRows() int {
	if m != nil {
		return m.Rows
	}
	return 0
}

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

var xxx_messageInfo_GetTableColumnsReq proto.InternalMessageInfo

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

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

var xxx_messageInfo_GetTableColumnsResp proto.InternalMessageInfo

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

var xxx_messageInfo_TruncateRelationReq proto.InternalMessageInfo

func (m *TruncateRelationReq) GetNewTableID() ID {
	if m != nil {
		return m.NewTableID
	}
	return 0
}

func (m *TruncateRelationReq) GetOldTableID() ID {
	if m != nil {
		return m.OldTableID
	}
	return 0
}

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

func (m *TruncateRelationReq) GetDatabaseName() string {
	if m != nil {
		return m.DatabaseName
	}
	return ""
}

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

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

var xxx_messageInfo_TruncateRelationResp proto.InternalMessageInfo

func (m *TruncateRelationResp) GetID() ID {
	if m != nil {
		return m.ID
	}
	return 0
}

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

var xxx_messageInfo_AddTableDefReq proto.InternalMessageInfo

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

func (m *AddTableDefReq) GetDatabaseName() string {
	if m != nil {
		return m.DatabaseName
	}
	return ""
}

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

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

var xxx_messageInfo_AddTableDefResp proto.InternalMessageInfo

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

var xxx_messageInfo_DelTableDefReq proto.InternalMessageInfo

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

func (m *DelTableDefReq) GetDatabaseName() string {
	if m != nil {
		return m.DatabaseName
	}
	return ""
}

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

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

var xxx_messageInfo_DelTableDefResp proto.InternalMessageInfo

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

var xxx_messageInfo_UpdateResp proto.InternalMessageInfo

func init() {
	proto.RegisterType((*AccessInfo)(nil), "memoryengine.AccessInfo")
	proto.RegisterType((*OpenDatabaseReq)(nil), "memoryengine.OpenDatabaseReq")
	proto.RegisterType((*OpenDatabaseResp)(nil), "memoryengine.OpenDatabaseResp")
	proto.RegisterType((*CreateDatabaseReq)(nil), "memoryengine.CreateDatabaseReq")
	proto.RegisterType((*CreateDatabaseResp)(nil), "memoryengine.CreateDatabaseResp")
	proto.RegisterType((*GetDatabasesReq)(nil), "memoryengine.GetDatabasesReq")
	proto.RegisterType((*GetDatabasesResp)(nil), "memoryengine.GetDatabasesResp")
	proto.RegisterType((*DeleteDatabaseReq)(nil), "memoryengine.DeleteDatabaseReq")
	proto.RegisterType((*DeleteDatabaseResp)(nil), "memoryengine.DeleteDatabaseResp")
	proto.RegisterType((*OpenRelationReq)(nil), "memoryengine.OpenRelationReq")
	proto.RegisterType((*OpenRelationResp)(nil), "memoryengine.OpenRelationResp")
	proto.RegisterType((*CreateRelationReq)(nil), "memoryengine.CreateRelationReq")
	proto.RegisterType((*CreateRelationResp)(nil), "memoryengine.CreateRelationResp")
	proto.RegisterType((*GetRelationsReq)(nil), "memoryengine.GetRelationsReq")
	proto.RegisterType((*GetRelationsResp)(nil), "memoryengine.GetRelationsResp")
	proto.RegisterType((*DeleteRelationReq)(nil), "memoryengine.DeleteRelationReq")
	proto.RegisterType((*DeleteRelationResp)(nil), "memoryengine.DeleteRelationResp")
	proto.RegisterType((*GetTableDefsReq)(nil), "memoryengine.GetTableDefsReq")
	proto.RegisterType((*GetTableDefsResp)(nil), "memoryengine.GetTableDefsResp")
	proto.RegisterType((*WriteResp)(nil), "memoryengine.WriteResp")
	proto.RegisterType((*NewTableIterReq)(nil), "memoryengine.NewTableIterReq")
	proto.RegisterType((*NewTableIterResp)(nil), "memoryengine.NewTableIterResp")
	proto.RegisterType((*ReadReq)(nil), "memoryengine.ReadReq")
	proto.RegisterType((*DeleteResp)(nil), "memoryengine.DeleteResp")
	proto.RegisterType((*GetPrimaryKeysReq)(nil), "memoryengine.GetPrimaryKeysReq")
	proto.RegisterType((*GetPrimaryKeysResp)(nil), "memoryengine.GetPrimaryKeysResp")
	proto.RegisterType((*CloseTableIterReq)(nil), "memoryengine.CloseTableIterReq")
	proto.RegisterType((*CloseTableIterResp)(nil), "memoryengine.CloseTableIterResp")
	proto.RegisterType((*GetHiddenKeysReq)(nil), "memoryengine.GetHiddenKeysReq")
	proto.RegisterType((*GetHiddenKeysResp)(nil), "memoryengine.GetHiddenKeysResp")
	proto.RegisterType((*TableStatsReq)(nil), "memoryengine.TableStatsReq")
	proto.RegisterType((*TableStatsResp)(nil), "memoryengine.TableStatsResp")
	proto.RegisterType((*GetTableColumnsReq)(nil), "memoryengine.GetTableColumnsReq")
	proto.RegisterType((*GetTableColumnsResp)(nil), "memoryengine.GetTableColumnsResp")
	proto.RegisterType((*TruncateRelationReq)(nil), "memoryengine.TruncateRelationReq")
	proto.RegisterType((*TruncateRelationResp)(nil), "memoryengine.TruncateRelationResp")
	proto.RegisterType((*AddTableDefReq)(nil), "memoryengine.AddTableDefReq")
	proto.RegisterType((*AddTableDefResp)(nil), "memoryengine.AddTableDefResp")
	proto.RegisterType((*DelTableDefReq)(nil), "memoryengine.DelTableDefReq")
	proto.RegisterType((*DelTableDefResp)(nil), "memoryengine.DelTableDefResp")
	proto.RegisterType((*UpdateResp)(nil), "memoryengine.UpdateResp")
}

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

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

func (m *OpenDatabaseReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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 *OpenDatabaseResp) 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 *OpenDatabaseResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OpenDatabaseResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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
	}
	if m.ID != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.ID))
		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 len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	{
		size, err := m.AccessInfo.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintOperations(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.ID != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *CreateDatabaseResp) 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 *CreateDatabaseResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *GetDatabasesReq) 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 *GetDatabasesReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetDatabasesReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		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 *GetDatabasesResp) 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 *GetDatabasesResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *DeleteDatabaseReq) 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 *DeleteDatabaseReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeleteDatabaseReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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 *DeleteDatabaseResp) 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 *DeleteDatabaseResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *OpenRelationReq) 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 *OpenRelationReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OpenRelationReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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] = 0x1a
	}
	if len(m.DatabaseName) > 0 {
		i -= len(m.DatabaseName)
		copy(dAtA[i:], m.DatabaseName)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.DatabaseName)))
		i--
		dAtA[i] = 0x12
	}
	if m.DatabaseID != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.DatabaseID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *OpenRelationResp) 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 *OpenRelationResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OpenRelationResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RelationName) > 0 {
		i -= len(m.RelationName)
		copy(dAtA[i:], m.RelationName)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.RelationName)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.DatabaseName) > 0 {
		i -= len(m.DatabaseName)
		copy(dAtA[i:], m.DatabaseName)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.DatabaseName)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Type != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if m.ID != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *CreateRelationReq) 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 *CreateRelationReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreateRelationReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Defs) > 0 {
		for iNdEx := len(m.Defs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Defs[iNdEx].ProtoSize()
				i -= size
				if _, err := m.Defs[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintOperations(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if m.Type != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x28
	}
	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] = 0x22
	}
	if len(m.DatabaseName) > 0 {
		i -= len(m.DatabaseName)
		copy(dAtA[i:], m.DatabaseName)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.DatabaseName)))
		i--
		dAtA[i] = 0x1a
	}
	if m.DatabaseID != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.DatabaseID))
		i--
		dAtA[i] = 0x10
	}
	if m.ID != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *CreateRelationResp) 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 *CreateRelationResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *GetRelationsReq) 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 *GetRelationsReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetRelationsReq) 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] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *GetRelationsResp) 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 *GetRelationsResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *DeleteRelationReq) 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 *DeleteRelationReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeleteRelationReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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] = 0x1a
	}
	if len(m.DatabaseName) > 0 {
		i -= len(m.DatabaseName)
		copy(dAtA[i:], m.DatabaseName)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.DatabaseName)))
		i--
		dAtA[i] = 0x12
	}
	if m.DatabaseID != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.DatabaseID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *DeleteRelationResp) 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 *DeleteRelationResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *GetTableDefsReq) 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 *GetTableDefsReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetTableDefsReq) 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] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *GetTableDefsResp) 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 *GetTableDefsResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *WriteResp) 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 *WriteResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WriteResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *NewTableIterReq) 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 *NewTableIterReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *NewTableIterResp) 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 *NewTableIterResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *ReadReq) 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 *ReadReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ReadReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ColNames) > 0 {
		for iNdEx := len(m.ColNames) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ColNames[iNdEx])
			copy(dAtA[i:], m.ColNames[iNdEx])
			i = encodeVarintOperations(dAtA, i, uint64(len(m.ColNames[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.IterID != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.IterID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *DeleteResp) 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 *DeleteResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeleteResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *GetPrimaryKeysReq) 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 *GetPrimaryKeysReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetPrimaryKeysReq) 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] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *GetPrimaryKeysResp) 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 *GetPrimaryKeysResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *CloseTableIterReq) 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 *CloseTableIterReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *CloseTableIterResp) 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 *CloseTableIterResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CloseTableIterResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *GetHiddenKeysReq) 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 *GetHiddenKeysReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetHiddenKeysReq) 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] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *GetHiddenKeysResp) 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 *GetHiddenKeysResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *TableStatsReq) 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 *TableStatsReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TableStatsReq) 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] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TableStatsResp) 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 *TableStatsResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *GetTableColumnsReq) 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 *GetTableColumnsReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetTableColumnsReq) 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] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *GetTableColumnsResp) 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 *GetTableColumnsResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *TruncateRelationReq) 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 *TruncateRelationReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TruncateRelationReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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] = 0x2a
	}
	if len(m.DatabaseName) > 0 {
		i -= len(m.DatabaseName)
		copy(dAtA[i:], m.DatabaseName)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.DatabaseName)))
		i--
		dAtA[i] = 0x22
	}
	if m.DatabaseID != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.DatabaseID))
		i--
		dAtA[i] = 0x18
	}
	if m.OldTableID != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.OldTableID))
		i--
		dAtA[i] = 0x10
	}
	if m.NewTableID != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.NewTableID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TruncateRelationResp) 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 *TruncateRelationResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *AddTableDefReq) 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 *AddTableDefReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddTableDefReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Def.ProtoSize()
		i -= size
		if _, err := m.Def.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintOperations(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	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] = 0x1a
	}
	if len(m.DatabaseName) > 0 {
		i -= len(m.DatabaseName)
		copy(dAtA[i:], m.DatabaseName)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.DatabaseName)))
		i--
		dAtA[i] = 0x12
	}
	if m.TableID != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.TableID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *AddTableDefResp) 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 *AddTableDefResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AddTableDefResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *DelTableDefReq) 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 *DelTableDefReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DelTableDefReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Def.ProtoSize()
		i -= size
		if _, err := m.Def.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintOperations(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	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] = 0x1a
	}
	if len(m.DatabaseName) > 0 {
		i -= len(m.DatabaseName)
		copy(dAtA[i:], m.DatabaseName)
		i = encodeVarintOperations(dAtA, i, uint64(len(m.DatabaseName)))
		i--
		dAtA[i] = 0x12
	}
	if m.TableID != 0 {
		i = encodeVarintOperations(dAtA, i, uint64(m.TableID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *DelTableDefResp) 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 *DelTableDefResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DelTableDefResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *UpdateResp) 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 *UpdateResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UpdateResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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 *OpenDatabaseReq) 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))
	}
	return n
}

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

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

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

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

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

func (m *DeleteDatabaseReq) 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))
	}
	return n
}

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

func (m *OpenRelationReq) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DatabaseID != 0 {
		n += 1 + sovOperations(uint64(m.DatabaseID))
	}
	l = len(m.DatabaseName)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	return n
}

func (m *OpenRelationResp) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovOperations(uint64(m.ID))
	}
	if m.Type != 0 {
		n += 1 + sovOperations(uint64(m.Type))
	}
	l = len(m.DatabaseName)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	l = len(m.RelationName)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	return n
}

func (m *CreateRelationReq) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovOperations(uint64(m.ID))
	}
	if m.DatabaseID != 0 {
		n += 1 + sovOperations(uint64(m.DatabaseID))
	}
	l = len(m.DatabaseName)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovOperations(uint64(m.Type))
	}
	if len(m.Defs) > 0 {
		for _, e := range m.Defs {
			l = e.ProtoSize()
			n += 1 + l + sovOperations(uint64(l))
		}
	}
	return n
}

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

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

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

func (m *DeleteRelationReq) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DatabaseID != 0 {
		n += 1 + sovOperations(uint64(m.DatabaseID))
	}
	l = len(m.DatabaseName)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	return n
}

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

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

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

func (m *WriteResp) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

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

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

func (m *ReadReq) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IterID != 0 {
		n += 1 + sovOperations(uint64(m.IterID))
	}
	if len(m.ColNames) > 0 {
		for _, s := range m.ColNames {
			l = len(s)
			n += 1 + l + sovOperations(uint64(l))
		}
	}
	return n
}

func (m *DeleteResp) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

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

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

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

func (m *CloseTableIterResp) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

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

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

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

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

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

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

func (m *TruncateRelationReq) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NewTableID != 0 {
		n += 1 + sovOperations(uint64(m.NewTableID))
	}
	if m.OldTableID != 0 {
		n += 1 + sovOperations(uint64(m.OldTableID))
	}
	if m.DatabaseID != 0 {
		n += 1 + sovOperations(uint64(m.DatabaseID))
	}
	l = len(m.DatabaseName)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	return n
}

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

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

func (m *AddTableDefResp) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

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

func (m *DelTableDefResp) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *UpdateResp) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	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 *OpenDatabaseReq) 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: OpenDatabaseReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OpenDatabaseReq: 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
		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 *OpenDatabaseResp) 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: OpenDatabaseResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OpenDatabaseResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= ID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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
		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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= ID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 3:
			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
		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 *CreateDatabaseResp) 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: CreateDatabaseResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateDatabaseResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= ID(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 *GetDatabasesReq) 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: GetDatabasesReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetDatabasesReq: 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
		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 *GetDatabasesResp) 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: GetDatabasesResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetDatabasesResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Names", 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.Names = append(m.Names, 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 *DeleteDatabaseReq) 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: DeleteDatabaseReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteDatabaseReq: 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
		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 *DeleteDatabaseResp) 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: DeleteDatabaseResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteDatabaseResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= ID(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 *OpenRelationReq) 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: OpenRelationReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OpenRelationReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 |= ID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DatabaseName", 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.DatabaseName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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
		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 *OpenRelationResp) 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: OpenRelationResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OpenRelationResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= ID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= RelationType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DatabaseName", 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.DatabaseName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelationName", 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.RelationName = 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 *CreateRelationReq) 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: CreateRelationReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateRelationReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= ID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 |= ID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DatabaseName", 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.DatabaseName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			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 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= RelationType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Defs", 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
			}
			var v github_com_matrixorigin_matrixone_pkg_vm_engine.TableDefPB
			m.Defs = append(m.Defs, v)
			if err := m.Defs[len(m.Defs)-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 *CreateRelationResp) 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: CreateRelationResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateRelationResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= ID(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 *GetRelationsReq) 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: GetRelationsReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetRelationsReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 |= ID(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 *GetRelationsResp) 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: GetRelationsResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetRelationsResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Names", 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.Names = append(m.Names, 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 *DeleteRelationReq) 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: DeleteRelationReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteRelationReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 |= ID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DatabaseName", 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.DatabaseName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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
		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 *DeleteRelationResp) 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: DeleteRelationResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteRelationResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= ID(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 *GetTableDefsReq) 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: GetTableDefsReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetTableDefsReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 |= ID(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 *GetTableDefsResp) 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: GetTableDefsResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetTableDefsResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Defs", 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
			}
			var v github_com_matrixorigin_matrixone_pkg_vm_engine.TableDefPB
			m.Defs = append(m.Defs, v)
			if err := m.Defs[len(m.Defs)-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 *WriteResp) 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: WriteResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WriteResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		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 *NewTableIterReq) 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: NewTableIterReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NewTableIterReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 |= ID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Expr", 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 m.Expr == nil {
				m.Expr = &plan.Expr{}
			}
			if err := m.Expr.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 *NewTableIterResp) 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: NewTableIterResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NewTableIterResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IterID", wireType)
			}
			m.IterID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IterID |= ID(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 *ReadReq) 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: ReadReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReadReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IterID", wireType)
			}
			m.IterID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IterID |= ID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ColNames", 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.ColNames = append(m.ColNames, 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 *DeleteResp) 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: DeleteResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		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 *GetPrimaryKeysReq) 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: GetPrimaryKeysReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetPrimaryKeysReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 |= ID(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 *GetPrimaryKeysResp) 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: GetPrimaryKeysResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetPrimaryKeysResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Attrs", 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
			}
			var v github_com_matrixorigin_matrixone_pkg_vm_engine.Attribute
			m.Attrs = append(m.Attrs, v)
			if err := m.Attrs[len(m.Attrs)-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 *CloseTableIterReq) 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: CloseTableIterReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CloseTableIterReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IterID", wireType)
			}
			m.IterID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IterID |= ID(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 *CloseTableIterResp) 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: CloseTableIterResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CloseTableIterResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		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 *GetHiddenKeysReq) 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: GetHiddenKeysReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetHiddenKeysReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 |= ID(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 *GetHiddenKeysResp) 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: GetHiddenKeysResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetHiddenKeysResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Attrs", 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
			}
			var v github_com_matrixorigin_matrixone_pkg_vm_engine.Attribute
			m.Attrs = append(m.Attrs, v)
			if err := m.Attrs[len(m.Attrs)-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 *TableStatsReq) 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: TableStatsReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TableStatsReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 |= ID(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 *TableStatsResp) 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: TableStatsResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TableStatsResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rows", wireType)
			}
			m.Rows = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Rows |= int(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 *GetTableColumnsReq) 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: GetTableColumnsReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetTableColumnsReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 |= ID(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 *GetTableColumnsResp) 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: GetTableColumnsResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetTableColumnsResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Attrs", 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
			}
			var v github_com_matrixorigin_matrixone_pkg_vm_engine.Attribute
			m.Attrs = append(m.Attrs, v)
			if err := m.Attrs[len(m.Attrs)-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 *TruncateRelationReq) 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: TruncateRelationReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TruncateRelationReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewTableID", wireType)
			}
			m.NewTableID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NewTableID |= ID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OldTableID", wireType)
			}
			m.OldTableID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OldTableID |= ID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 |= ID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DatabaseName", 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.DatabaseName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			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
		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 *TruncateRelationResp) 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: TruncateRelationResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TruncateRelationResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= ID(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 *AddTableDefReq) 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: AddTableDefReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddTableDefReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 |= ID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DatabaseName", 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.DatabaseName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Def", 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
			}
			if err := m.Def.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 *AddTableDefResp) 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: AddTableDefResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AddTableDefResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		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 *DelTableDefReq) 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: DelTableDefReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelTableDefReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 |= ID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DatabaseName", 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.DatabaseName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Def", 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
			}
			if err := m.Def.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 *DelTableDefResp) 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: DelTableDefResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelTableDefResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		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 *UpdateResp) 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: UpdateResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UpdateResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		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")
)