explain.pb.go

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

package tipb

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"

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

// 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.ProtoPackageIsVersion3 // please upgrade the proto package

type TaskType int32

const (
	TaskType_unknown  TaskType = 0
	TaskType_root     TaskType = 1
	TaskType_cop      TaskType = 2
	TaskType_batchCop TaskType = 3
	TaskType_mpp      TaskType = 4
)

var TaskType_name = map[int32]string{
	0: "unknown",
	1: "root",
	2: "cop",
	3: "batchCop",
	4: "mpp",
}

var TaskType_value = map[string]int32{
	"unknown":  0,
	"root":     1,
	"cop":      2,
	"batchCop": 3,
	"mpp":      4,
}

func (x TaskType) String() string {
	return proto.EnumName(TaskType_name, int32(x))
}

func (TaskType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_4242acda8806438c, []int{0}
}

type StoreType int32

const (
	StoreType_unspecified StoreType = 0
	StoreType_tidb        StoreType = 1
	StoreType_tikv        StoreType = 2
	StoreType_tiflash     StoreType = 3
)

var StoreType_name = map[int32]string{
	0: "unspecified",
	1: "tidb",
	2: "tikv",
	3: "tiflash",
}

var StoreType_value = map[string]int32{
	"unspecified": 0,
	"tidb":        1,
	"tikv":        2,
	"tiflash":     3,
}

func (x StoreType) String() string {
	return proto.EnumName(StoreType_name, int32(x))
}

func (StoreType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_4242acda8806438c, []int{1}
}

type OperatorLabel int32

const (
	// empty is not expected to be used.
	OperatorLabel_empty         OperatorLabel = 0
	OperatorLabel_buildSide     OperatorLabel = 1
	OperatorLabel_probeSide     OperatorLabel = 2
	OperatorLabel_seedPart      OperatorLabel = 3
	OperatorLabel_recursivePart OperatorLabel = 4
)

var OperatorLabel_name = map[int32]string{
	0: "empty",
	1: "buildSide",
	2: "probeSide",
	3: "seedPart",
	4: "recursivePart",
}

var OperatorLabel_value = map[string]int32{
	"empty":         0,
	"buildSide":     1,
	"probeSide":     2,
	"seedPart":      3,
	"recursivePart": 4,
}

func (x OperatorLabel) String() string {
	return proto.EnumName(OperatorLabel_name, int32(x))
}

func (OperatorLabel) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_4242acda8806438c, []int{2}
}

type ExplainData struct {
	Main *ExplainOperator   `protobuf:"bytes,1,opt,name=main,proto3" json:"main,omitempty"`
	Ctes []*ExplainOperator `protobuf:"bytes,2,rep,name=ctes,proto3" json:"ctes,omitempty"`
	// with_runtime_stats represents if runtime stats are available.
	// If not available, the act_rows, *_exec_info, memory_bytes and disk_bytes should not be used.
	WithRuntimeStats bool `protobuf:"varint,3,opt,name=with_runtime_stats,json=withRuntimeStats,proto3" json:"with_runtime_stats,omitempty"`
	// If discarded_due_to_too_long is true. The main and ctes fields should be empty and should not be used.
	// This field can be changed to a enum or int if we need to represent more states in the future.
	DiscardedDueToTooLong bool     `protobuf:"varint,4,opt,name=discarded_due_to_too_long,json=discardedDueToTooLong,proto3" json:"discarded_due_to_too_long,omitempty"`
	XXX_NoUnkeyedLiteral  struct{} `json:"-"`
	XXX_unrecognized      []byte   `json:"-"`
	XXX_sizecache         int32    `json:"-"`
}

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

var xxx_messageInfo_ExplainData proto.InternalMessageInfo

func (m *ExplainData) GetMain() *ExplainOperator {
	if m != nil {
		return m.Main
	}
	return nil
}

func (m *ExplainData) GetCtes() []*ExplainOperator {
	if m != nil {
		return m.Ctes
	}
	return nil
}

func (m *ExplainData) GetWithRuntimeStats() bool {
	if m != nil {
		return m.WithRuntimeStats
	}
	return false
}

func (m *ExplainData) GetDiscardedDueToTooLong() bool {
	if m != nil {
		return m.DiscardedDueToTooLong
	}
	return false
}

type ExplainOperator struct {
	Name     string             `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Children []*ExplainOperator `protobuf:"bytes,2,rep,name=children,proto3" json:"children,omitempty"`
	Labels   []OperatorLabel    `protobuf:"varint,3,rep,packed,name=labels,proto3,enum=tipb.OperatorLabel" json:"labels,omitempty"`
	// the cost of the current operator
	Cost      float64   `protobuf:"fixed64,4,opt,name=cost,proto3" json:"cost,omitempty"`
	EstRows   float64   `protobuf:"fixed64,5,opt,name=est_rows,json=estRows,proto3" json:"est_rows,omitempty"`
	ActRows   uint64    `protobuf:"varint,6,opt,name=act_rows,json=actRows,proto3" json:"act_rows,omitempty"`
	TaskType  TaskType  `protobuf:"varint,7,opt,name=task_type,json=taskType,proto3,enum=tipb.TaskType" json:"task_type,omitempty"`
	StoreType StoreType `protobuf:"varint,8,opt,name=store_type,json=storeType,proto3,enum=tipb.StoreType" json:"store_type,omitempty"`
	// The XXXReader/XXXScan/MemTable/PointGet/BatchPointGet may use this
	AccessObjects     []*AccessObject `protobuf:"bytes,9,rep,name=access_objects,json=accessObjects,proto3" json:"access_objects,omitempty"`
	OperatorInfo      string          `protobuf:"bytes,10,opt,name=operator_info,json=operatorInfo,proto3" json:"operator_info,omitempty"`
	RootBasicExecInfo string          `protobuf:"bytes,11,opt,name=root_basic_exec_info,json=rootBasicExecInfo,proto3" json:"root_basic_exec_info,omitempty"`
	RootGroupExecInfo []string        `protobuf:"bytes,12,rep,name=root_group_exec_info,json=rootGroupExecInfo,proto3" json:"root_group_exec_info,omitempty"`
	CopExecInfo       string          `protobuf:"bytes,13,opt,name=cop_exec_info,json=copExecInfo,proto3" json:"cop_exec_info,omitempty"`
	// memory_bytes and disk_bytes are expected to be displayed as "N/A" when they are -1,
	// this will be consistent with the result of EXPLAIN ANALYZE.
	MemoryBytes          int64    `protobuf:"varint,14,opt,name=memory_bytes,json=memoryBytes,proto3" json:"memory_bytes,omitempty"`
	DiskBytes            int64    `protobuf:"varint,15,opt,name=disk_bytes,json=diskBytes,proto3" json:"disk_bytes,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ExplainOperator proto.InternalMessageInfo

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

func (m *ExplainOperator) GetChildren() []*ExplainOperator {
	if m != nil {
		return m.Children
	}
	return nil
}

func (m *ExplainOperator) GetLabels() []OperatorLabel {
	if m != nil {
		return m.Labels
	}
	return nil
}

func (m *ExplainOperator) GetCost() float64 {
	if m != nil {
		return m.Cost
	}
	return 0
}

func (m *ExplainOperator) GetEstRows() float64 {
	if m != nil {
		return m.EstRows
	}
	return 0
}

func (m *ExplainOperator) GetActRows() uint64 {
	if m != nil {
		return m.ActRows
	}
	return 0
}

func (m *ExplainOperator) GetTaskType() TaskType {
	if m != nil {
		return m.TaskType
	}
	return TaskType_unknown
}

func (m *ExplainOperator) GetStoreType() StoreType {
	if m != nil {
		return m.StoreType
	}
	return StoreType_unspecified
}

func (m *ExplainOperator) GetAccessObjects() []*AccessObject {
	if m != nil {
		return m.AccessObjects
	}
	return nil
}

func (m *ExplainOperator) GetOperatorInfo() string {
	if m != nil {
		return m.OperatorInfo
	}
	return ""
}

func (m *ExplainOperator) GetRootBasicExecInfo() string {
	if m != nil {
		return m.RootBasicExecInfo
	}
	return ""
}

func (m *ExplainOperator) GetRootGroupExecInfo() []string {
	if m != nil {
		return m.RootGroupExecInfo
	}
	return nil
}

func (m *ExplainOperator) GetCopExecInfo() string {
	if m != nil {
		return m.CopExecInfo
	}
	return ""
}

func (m *ExplainOperator) GetMemoryBytes() int64 {
	if m != nil {
		return m.MemoryBytes
	}
	return 0
}

func (m *ExplainOperator) GetDiskBytes() int64 {
	if m != nil {
		return m.DiskBytes
	}
	return 0
}

type AccessObject struct {
	// Types that are valid to be assigned to AccessObject:
	//	*AccessObject_ScanObject
	//	*AccessObject_DynamicPartitionObjects
	//	*AccessObject_OtherObject
	AccessObject         isAccessObject_AccessObject `protobuf_oneof:"access_object"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

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

var xxx_messageInfo_AccessObject proto.InternalMessageInfo

type isAccessObject_AccessObject interface {
	isAccessObject_AccessObject()
	MarshalTo([]byte) (int, error)
	Size() int
}

type AccessObject_ScanObject struct {
	ScanObject *ScanAccessObject `protobuf:"bytes,1,opt,name=scan_object,json=scanObject,proto3,oneof" json:"scan_object,omitempty"`
}
type AccessObject_DynamicPartitionObjects struct {
	DynamicPartitionObjects *DynamicPartitionAccessObjects `protobuf:"bytes,2,opt,name=dynamic_partition_objects,json=dynamicPartitionObjects,proto3,oneof" json:"dynamic_partition_objects,omitempty"`
}
type AccessObject_OtherObject struct {
	OtherObject string `protobuf:"bytes,3,opt,name=other_object,json=otherObject,proto3,oneof" json:"other_object,omitempty"`
}

func (*AccessObject_ScanObject) isAccessObject_AccessObject()              {}
func (*AccessObject_DynamicPartitionObjects) isAccessObject_AccessObject() {}
func (*AccessObject_OtherObject) isAccessObject_AccessObject()             {}

func (m *AccessObject) GetAccessObject() isAccessObject_AccessObject {
	if m != nil {
		return m.AccessObject
	}
	return nil
}

func (m *AccessObject) GetScanObject() *ScanAccessObject {
	if x, ok := m.GetAccessObject().(*AccessObject_ScanObject); ok {
		return x.ScanObject
	}
	return nil
}

func (m *AccessObject) GetDynamicPartitionObjects() *DynamicPartitionAccessObjects {
	if x, ok := m.GetAccessObject().(*AccessObject_DynamicPartitionObjects); ok {
		return x.DynamicPartitionObjects
	}
	return nil
}

func (m *AccessObject) GetOtherObject() string {
	if x, ok := m.GetAccessObject().(*AccessObject_OtherObject); ok {
		return x.OtherObject
	}
	return ""
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*AccessObject) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*AccessObject_ScanObject)(nil),
		(*AccessObject_DynamicPartitionObjects)(nil),
		(*AccessObject_OtherObject)(nil),
	}
}

type DynamicPartitionAccessObjects struct {
	Objects              []*DynamicPartitionAccessObject `protobuf:"bytes,1,rep,name=objects,proto3" json:"objects,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
	XXX_unrecognized     []byte                          `json:"-"`
	XXX_sizecache        int32                           `json:"-"`
}

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

var xxx_messageInfo_DynamicPartitionAccessObjects proto.InternalMessageInfo

func (m *DynamicPartitionAccessObjects) GetObjects() []*DynamicPartitionAccessObject {
	if m != nil {
		return m.Objects
	}
	return nil
}

// DynamicPartitionAccessObject represents the partitions accessed by the children of this operator.
type DynamicPartitionAccessObject struct {
	Database             string   `protobuf:"bytes,1,opt,name=database,proto3" json:"database,omitempty"`
	Table                string   `protobuf:"bytes,2,opt,name=table,proto3" json:"table,omitempty"`
	AllPartitions        bool     `protobuf:"varint,3,opt,name=all_partitions,json=allPartitions,proto3" json:"all_partitions,omitempty"`
	Partitions           []string `protobuf:"bytes,4,rep,name=partitions,proto3" json:"partitions,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DynamicPartitionAccessObject proto.InternalMessageInfo

func (m *DynamicPartitionAccessObject) GetDatabase() string {
	if m != nil {
		return m.Database
	}
	return ""
}

func (m *DynamicPartitionAccessObject) GetTable() string {
	if m != nil {
		return m.Table
	}
	return ""
}

func (m *DynamicPartitionAccessObject) GetAllPartitions() bool {
	if m != nil {
		return m.AllPartitions
	}
	return false
}

func (m *DynamicPartitionAccessObject) GetPartitions() []string {
	if m != nil {
		return m.Partitions
	}
	return nil
}

// ScanAccessObject represents the access to a single table. It may contain multiple indexes and multiple partitions.
type ScanAccessObject struct {
	Database             string         `protobuf:"bytes,1,opt,name=database,proto3" json:"database,omitempty"`
	Table                string         `protobuf:"bytes,2,opt,name=table,proto3" json:"table,omitempty"`
	Indexes              []*IndexAccess `protobuf:"bytes,3,rep,name=indexes,proto3" json:"indexes,omitempty"`
	Partitions           []string       `protobuf:"bytes,4,rep,name=partitions,proto3" json:"partitions,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_ScanAccessObject proto.InternalMessageInfo

func (m *ScanAccessObject) GetDatabase() string {
	if m != nil {
		return m.Database
	}
	return ""
}

func (m *ScanAccessObject) GetTable() string {
	if m != nil {
		return m.Table
	}
	return ""
}

func (m *ScanAccessObject) GetIndexes() []*IndexAccess {
	if m != nil {
		return m.Indexes
	}
	return nil
}

func (m *ScanAccessObject) GetPartitions() []string {
	if m != nil {
		return m.Partitions
	}
	return nil
}

type IndexAccess struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Cols                 []string `protobuf:"bytes,2,rep,name=cols,proto3" json:"cols,omitempty"`
	IsClusteredIndex     bool     `protobuf:"varint,3,opt,name=is_clustered_index,json=isClusteredIndex,proto3" json:"is_clustered_index,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_IndexAccess proto.InternalMessageInfo

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

func (m *IndexAccess) GetCols() []string {
	if m != nil {
		return m.Cols
	}
	return nil
}

func (m *IndexAccess) GetIsClusteredIndex() bool {
	if m != nil {
		return m.IsClusteredIndex
	}
	return false
}

func init() {
	proto.RegisterEnum("tipb.TaskType", TaskType_name, TaskType_value)
	proto.RegisterEnum("tipb.StoreType", StoreType_name, StoreType_value)
	proto.RegisterEnum("tipb.OperatorLabel", OperatorLabel_name, OperatorLabel_value)
	proto.RegisterType((*ExplainData)(nil), "tipb.ExplainData")
	proto.RegisterType((*ExplainOperator)(nil), "tipb.ExplainOperator")
	proto.RegisterType((*AccessObject)(nil), "tipb.AccessObject")
	proto.RegisterType((*DynamicPartitionAccessObjects)(nil), "tipb.DynamicPartitionAccessObjects")
	proto.RegisterType((*DynamicPartitionAccessObject)(nil), "tipb.DynamicPartitionAccessObject")
	proto.RegisterType((*ScanAccessObject)(nil), "tipb.ScanAccessObject")
	proto.RegisterType((*IndexAccess)(nil), "tipb.IndexAccess")
}

func init() { proto.RegisterFile("explain.proto", fileDescriptor_4242acda8806438c) }

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

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

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

func (m *ExplainData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.DiscardedDueToTooLong {
		i--
		if m.DiscardedDueToTooLong {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.WithRuntimeStats {
		i--
		if m.WithRuntimeStats {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Ctes) > 0 {
		for iNdEx := len(m.Ctes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Ctes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintExplain(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Main != nil {
		{
			size, err := m.Main.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExplain(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ExplainOperator) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.DiskBytes != 0 {
		i = encodeVarintExplain(dAtA, i, uint64(m.DiskBytes))
		i--
		dAtA[i] = 0x78
	}
	if m.MemoryBytes != 0 {
		i = encodeVarintExplain(dAtA, i, uint64(m.MemoryBytes))
		i--
		dAtA[i] = 0x70
	}
	if len(m.CopExecInfo) > 0 {
		i -= len(m.CopExecInfo)
		copy(dAtA[i:], m.CopExecInfo)
		i = encodeVarintExplain(dAtA, i, uint64(len(m.CopExecInfo)))
		i--
		dAtA[i] = 0x6a
	}
	if len(m.RootGroupExecInfo) > 0 {
		for iNdEx := len(m.RootGroupExecInfo) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.RootGroupExecInfo[iNdEx])
			copy(dAtA[i:], m.RootGroupExecInfo[iNdEx])
			i = encodeVarintExplain(dAtA, i, uint64(len(m.RootGroupExecInfo[iNdEx])))
			i--
			dAtA[i] = 0x62
		}
	}
	if len(m.RootBasicExecInfo) > 0 {
		i -= len(m.RootBasicExecInfo)
		copy(dAtA[i:], m.RootBasicExecInfo)
		i = encodeVarintExplain(dAtA, i, uint64(len(m.RootBasicExecInfo)))
		i--
		dAtA[i] = 0x5a
	}
	if len(m.OperatorInfo) > 0 {
		i -= len(m.OperatorInfo)
		copy(dAtA[i:], m.OperatorInfo)
		i = encodeVarintExplain(dAtA, i, uint64(len(m.OperatorInfo)))
		i--
		dAtA[i] = 0x52
	}
	if len(m.AccessObjects) > 0 {
		for iNdEx := len(m.AccessObjects) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AccessObjects[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintExplain(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4a
		}
	}
	if m.StoreType != 0 {
		i = encodeVarintExplain(dAtA, i, uint64(m.StoreType))
		i--
		dAtA[i] = 0x40
	}
	if m.TaskType != 0 {
		i = encodeVarintExplain(dAtA, i, uint64(m.TaskType))
		i--
		dAtA[i] = 0x38
	}
	if m.ActRows != 0 {
		i = encodeVarintExplain(dAtA, i, uint64(m.ActRows))
		i--
		dAtA[i] = 0x30
	}
	if m.EstRows != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.EstRows))))
		i--
		dAtA[i] = 0x29
	}
	if m.Cost != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Cost))))
		i--
		dAtA[i] = 0x21
	}
	if len(m.Labels) > 0 {
		dAtA3 := make([]byte, len(m.Labels)*10)
		var j2 int
		for _, num := range m.Labels {
			for num >= 1<<7 {
				dAtA3[j2] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j2++
			}
			dAtA3[j2] = uint8(num)
			j2++
		}
		i -= j2
		copy(dAtA[i:], dAtA3[:j2])
		i = encodeVarintExplain(dAtA, i, uint64(j2))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Children) > 0 {
		for iNdEx := len(m.Children) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Children[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintExplain(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintExplain(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *AccessObject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.AccessObject != nil {
		{
			size := m.AccessObject.Size()
			i -= size
			if _, err := m.AccessObject.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *AccessObject_ScanObject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ScanObject != nil {
		{
			size, err := m.ScanObject.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExplain(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *AccessObject_DynamicPartitionObjects) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AccessObject_DynamicPartitionObjects) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DynamicPartitionObjects != nil {
		{
			size, err := m.DynamicPartitionObjects.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExplain(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *AccessObject_OtherObject) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AccessObject_OtherObject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.OtherObject)
	copy(dAtA[i:], m.OtherObject)
	i = encodeVarintExplain(dAtA, i, uint64(len(m.OtherObject)))
	i--
	dAtA[i] = 0x1a
	return len(dAtA) - i, nil
}
func (m *DynamicPartitionAccessObjects) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

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

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

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

func (m *DynamicPartitionAccessObject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Partitions) > 0 {
		for iNdEx := len(m.Partitions) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Partitions[iNdEx])
			copy(dAtA[i:], m.Partitions[iNdEx])
			i = encodeVarintExplain(dAtA, i, uint64(len(m.Partitions[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.AllPartitions {
		i--
		if m.AllPartitions {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Table) > 0 {
		i -= len(m.Table)
		copy(dAtA[i:], m.Table)
		i = encodeVarintExplain(dAtA, i, uint64(len(m.Table)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Database) > 0 {
		i -= len(m.Database)
		copy(dAtA[i:], m.Database)
		i = encodeVarintExplain(dAtA, i, uint64(len(m.Database)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ScanAccessObject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Partitions) > 0 {
		for iNdEx := len(m.Partitions) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Partitions[iNdEx])
			copy(dAtA[i:], m.Partitions[iNdEx])
			i = encodeVarintExplain(dAtA, i, uint64(len(m.Partitions[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Indexes) > 0 {
		for iNdEx := len(m.Indexes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Indexes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintExplain(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Table) > 0 {
		i -= len(m.Table)
		copy(dAtA[i:], m.Table)
		i = encodeVarintExplain(dAtA, i, uint64(len(m.Table)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Database) > 0 {
		i -= len(m.Database)
		copy(dAtA[i:], m.Database)
		i = encodeVarintExplain(dAtA, i, uint64(len(m.Database)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *IndexAccess) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.IsClusteredIndex {
		i--
		if m.IsClusteredIndex {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Cols) > 0 {
		for iNdEx := len(m.Cols) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Cols[iNdEx])
			copy(dAtA[i:], m.Cols[iNdEx])
			i = encodeVarintExplain(dAtA, i, uint64(len(m.Cols[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintExplain(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintExplain(dAtA []byte, offset int, v uint64) int {
	offset -= sovExplain(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *ExplainData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Main != nil {
		l = m.Main.Size()
		n += 1 + l + sovExplain(uint64(l))
	}
	if len(m.Ctes) > 0 {
		for _, e := range m.Ctes {
			l = e.Size()
			n += 1 + l + sovExplain(uint64(l))
		}
	}
	if m.WithRuntimeStats {
		n += 2
	}
	if m.DiscardedDueToTooLong {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ExplainOperator) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovExplain(uint64(l))
	}
	if len(m.Children) > 0 {
		for _, e := range m.Children {
			l = e.Size()
			n += 1 + l + sovExplain(uint64(l))
		}
	}
	if len(m.Labels) > 0 {
		l = 0
		for _, e := range m.Labels {
			l += sovExplain(uint64(e))
		}
		n += 1 + sovExplain(uint64(l)) + l
	}
	if m.Cost != 0 {
		n += 9
	}
	if m.EstRows != 0 {
		n += 9
	}
	if m.ActRows != 0 {
		n += 1 + sovExplain(uint64(m.ActRows))
	}
	if m.TaskType != 0 {
		n += 1 + sovExplain(uint64(m.TaskType))
	}
	if m.StoreType != 0 {
		n += 1 + sovExplain(uint64(m.StoreType))
	}
	if len(m.AccessObjects) > 0 {
		for _, e := range m.AccessObjects {
			l = e.Size()
			n += 1 + l + sovExplain(uint64(l))
		}
	}
	l = len(m.OperatorInfo)
	if l > 0 {
		n += 1 + l + sovExplain(uint64(l))
	}
	l = len(m.RootBasicExecInfo)
	if l > 0 {
		n += 1 + l + sovExplain(uint64(l))
	}
	if len(m.RootGroupExecInfo) > 0 {
		for _, s := range m.RootGroupExecInfo {
			l = len(s)
			n += 1 + l + sovExplain(uint64(l))
		}
	}
	l = len(m.CopExecInfo)
	if l > 0 {
		n += 1 + l + sovExplain(uint64(l))
	}
	if m.MemoryBytes != 0 {
		n += 1 + sovExplain(uint64(m.MemoryBytes))
	}
	if m.DiskBytes != 0 {
		n += 1 + sovExplain(uint64(m.DiskBytes))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AccessObject) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AccessObject != nil {
		n += m.AccessObject.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AccessObject_ScanObject) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ScanObject != nil {
		l = m.ScanObject.Size()
		n += 1 + l + sovExplain(uint64(l))
	}
	return n
}
func (m *AccessObject_DynamicPartitionObjects) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DynamicPartitionObjects != nil {
		l = m.DynamicPartitionObjects.Size()
		n += 1 + l + sovExplain(uint64(l))
	}
	return n
}
func (m *AccessObject_OtherObject) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OtherObject)
	n += 1 + l + sovExplain(uint64(l))
	return n
}
func (m *DynamicPartitionAccessObjects) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Objects) > 0 {
		for _, e := range m.Objects {
			l = e.Size()
			n += 1 + l + sovExplain(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DynamicPartitionAccessObject) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Database)
	if l > 0 {
		n += 1 + l + sovExplain(uint64(l))
	}
	l = len(m.Table)
	if l > 0 {
		n += 1 + l + sovExplain(uint64(l))
	}
	if m.AllPartitions {
		n += 2
	}
	if len(m.Partitions) > 0 {
		for _, s := range m.Partitions {
			l = len(s)
			n += 1 + l + sovExplain(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ScanAccessObject) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Database)
	if l > 0 {
		n += 1 + l + sovExplain(uint64(l))
	}
	l = len(m.Table)
	if l > 0 {
		n += 1 + l + sovExplain(uint64(l))
	}
	if len(m.Indexes) > 0 {
		for _, e := range m.Indexes {
			l = e.Size()
			n += 1 + l + sovExplain(uint64(l))
		}
	}
	if len(m.Partitions) > 0 {
		for _, s := range m.Partitions {
			l = len(s)
			n += 1 + l + sovExplain(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *IndexAccess) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovExplain(uint64(l))
	}
	if len(m.Cols) > 0 {
		for _, s := range m.Cols {
			l = len(s)
			n += 1 + l + sovExplain(uint64(l))
		}
	}
	if m.IsClusteredIndex {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovExplain(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozExplain(x uint64) (n int) {
	return sovExplain(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ExplainData) 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 ErrIntOverflowExplain
			}
			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: ExplainData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExplainData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Main", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExplain
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExplain
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Main == nil {
				m.Main = &ExplainOperator{}
			}
			if err := m.Main.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ctes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExplain
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExplain
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ctes = append(m.Ctes, &ExplainOperator{})
			if err := m.Ctes[len(m.Ctes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WithRuntimeStats", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.WithRuntimeStats = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DiscardedDueToTooLong", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DiscardedDueToTooLong = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipExplain(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExplain
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExplainOperator) 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 ErrIntOverflowExplain
			}
			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: ExplainOperator: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExplainOperator: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				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 ErrInvalidLengthExplain
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExplain
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Children", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExplain
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExplain
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Children = append(m.Children, &ExplainOperator{})
			if err := m.Children[len(m.Children)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType == 0 {
				var v OperatorLabel
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowExplain
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= OperatorLabel(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Labels = append(m.Labels, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowExplain
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthExplain
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthExplain
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.Labels) == 0 {
					m.Labels = make([]OperatorLabel, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v OperatorLabel
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowExplain
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= OperatorLabel(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Labels = append(m.Labels, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
		case 4:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cost", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Cost = float64(math.Float64frombits(v))
		case 5:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field EstRows", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.EstRows = float64(math.Float64frombits(v))
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActRows", wireType)
			}
			m.ActRows = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ActRows |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaskType", wireType)
			}
			m.TaskType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TaskType |= TaskType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StoreType", wireType)
			}
			m.StoreType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StoreType |= StoreType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccessObjects", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExplain
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExplain
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccessObjects = append(m.AccessObjects, &AccessObject{})
			if err := m.AccessObjects[len(m.AccessObjects)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OperatorInfo", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				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 ErrInvalidLengthExplain
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExplain
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OperatorInfo = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RootBasicExecInfo", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				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 ErrInvalidLengthExplain
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExplain
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RootBasicExecInfo = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RootGroupExecInfo", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				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 ErrInvalidLengthExplain
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExplain
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RootGroupExecInfo = append(m.RootGroupExecInfo, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CopExecInfo", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				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 ErrInvalidLengthExplain
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExplain
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CopExecInfo = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MemoryBytes", wireType)
			}
			m.MemoryBytes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MemoryBytes |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 15:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DiskBytes", wireType)
			}
			m.DiskBytes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DiskBytes |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipExplain(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExplain
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AccessObject) 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 ErrIntOverflowExplain
			}
			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: AccessObject: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AccessObject: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScanObject", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExplain
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExplain
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ScanAccessObject{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.AccessObject = &AccessObject_ScanObject{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DynamicPartitionObjects", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExplain
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExplain
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &DynamicPartitionAccessObjects{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.AccessObject = &AccessObject_DynamicPartitionObjects{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OtherObject", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				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 ErrInvalidLengthExplain
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExplain
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccessObject = &AccessObject_OtherObject{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExplain(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExplain
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DynamicPartitionAccessObject) 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 ErrIntOverflowExplain
			}
			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: DynamicPartitionAccessObject: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DynamicPartitionAccessObject: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Database", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				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 ErrInvalidLengthExplain
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExplain
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Database = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Table", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				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 ErrInvalidLengthExplain
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExplain
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Table = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllPartitions", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AllPartitions = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Partitions", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExplain
				}
				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 ErrInvalidLengthExplain
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExplain
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Partitions = append(m.Partitions, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExplain(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthExplain
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipExplain(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, ErrIntOverflowExplain
			}
			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, ErrIntOverflowExplain
				}
				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, ErrIntOverflowExplain
				}
				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, ErrInvalidLengthExplain
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupExplain
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthExplain
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthExplain        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowExplain          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupExplain = fmt.Errorf("proto: unexpected end of group")
)