explain.pb.go

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

package tipb

import (
	"fmt"

	proto "github.com/golang/protobuf/proto"

	math "math"

	encoding_binary "encoding/binary"

	io "io"
)

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

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 fileDescriptorExplain, []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 fileDescriptorExplain, []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 fileDescriptorExplain, []int{2} }

type ExplainData struct {
	Main *ExplainOperator   `protobuf:"bytes,1,opt,name=main" json:"main,omitempty"`
	Ctes []*ExplainOperator `protobuf:"bytes,2,rep,name=ctes" 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"`
}

func (m *ExplainData) Reset()                    { *m = ExplainData{} }
func (m *ExplainData) String() string            { return proto.CompactTextString(m) }
func (*ExplainData) ProtoMessage()               {}
func (*ExplainData) Descriptor() ([]byte, []int) { return fileDescriptorExplain, []int{0} }

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" json:"children,omitempty"`
	Labels   []OperatorLabel    `protobuf:"varint,3,rep,packed,name=labels,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" 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" 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"`
}

func (m *ExplainOperator) Reset()                    { *m = ExplainOperator{} }
func (m *ExplainOperator) String() string            { return proto.CompactTextString(m) }
func (*ExplainOperator) ProtoMessage()               {}
func (*ExplainOperator) Descriptor() ([]byte, []int) { return fileDescriptorExplain, []int{1} }

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"`
}

func (m *AccessObject) Reset()                    { *m = AccessObject{} }
func (m *AccessObject) String() string            { return proto.CompactTextString(m) }
func (*AccessObject) ProtoMessage()               {}
func (*AccessObject) Descriptor() ([]byte, []int) { return fileDescriptorExplain, []int{2} }

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,oneof"`
}
type AccessObject_DynamicPartitionObjects struct {
	DynamicPartitionObjects *DynamicPartitionAccessObjects `protobuf:"bytes,2,opt,name=dynamic_partition_objects,json=dynamicPartitionObjects,oneof"`
}
type AccessObject_OtherObject struct {
	OtherObject string `protobuf:"bytes,3,opt,name=other_object,json=otherObject,proto3,oneof"`
}

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_OneofFuncs is for the internal use of the proto package.
func (*AccessObject) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _AccessObject_OneofMarshaler, _AccessObject_OneofUnmarshaler, _AccessObject_OneofSizer, []interface{}{
		(*AccessObject_ScanObject)(nil),
		(*AccessObject_DynamicPartitionObjects)(nil),
		(*AccessObject_OtherObject)(nil),
	}
}

func _AccessObject_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*AccessObject)
	// access_object
	switch x := m.AccessObject.(type) {
	case *AccessObject_ScanObject:
		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ScanObject); err != nil {
			return err
		}
	case *AccessObject_DynamicPartitionObjects:
		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.DynamicPartitionObjects); err != nil {
			return err
		}
	case *AccessObject_OtherObject:
		_ = b.EncodeVarint(3<<3 | proto.WireBytes)
		_ = b.EncodeStringBytes(x.OtherObject)
	case nil:
	default:
		return fmt.Errorf("AccessObject.AccessObject has unexpected type %T", x)
	}
	return nil
}

func _AccessObject_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*AccessObject)
	switch tag {
	case 1: // access_object.scan_object
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ScanAccessObject)
		err := b.DecodeMessage(msg)
		m.AccessObject = &AccessObject_ScanObject{msg}
		return true, err
	case 2: // access_object.dynamic_partition_objects
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(DynamicPartitionAccessObjects)
		err := b.DecodeMessage(msg)
		m.AccessObject = &AccessObject_DynamicPartitionObjects{msg}
		return true, err
	case 3: // access_object.other_object
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.AccessObject = &AccessObject_OtherObject{x}
		return true, err
	default:
		return false, nil
	}
}

func _AccessObject_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*AccessObject)
	// access_object
	switch x := m.AccessObject.(type) {
	case *AccessObject_ScanObject:
		s := proto.Size(x.ScanObject)
		n += proto.SizeVarint(1<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *AccessObject_DynamicPartitionObjects:
		s := proto.Size(x.DynamicPartitionObjects)
		n += proto.SizeVarint(2<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *AccessObject_OtherObject:
		n += proto.SizeVarint(3<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(len(x.OtherObject)))
		n += len(x.OtherObject)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type DynamicPartitionAccessObjects struct {
	Objects []*DynamicPartitionAccessObject `protobuf:"bytes,1,rep,name=objects" json:"objects,omitempty"`
}

func (m *DynamicPartitionAccessObjects) Reset()         { *m = DynamicPartitionAccessObjects{} }
func (m *DynamicPartitionAccessObjects) String() string { return proto.CompactTextString(m) }
func (*DynamicPartitionAccessObjects) ProtoMessage()    {}
func (*DynamicPartitionAccessObjects) Descriptor() ([]byte, []int) {
	return fileDescriptorExplain, []int{3}
}

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" json:"partitions,omitempty"`
}

func (m *DynamicPartitionAccessObject) Reset()         { *m = DynamicPartitionAccessObject{} }
func (m *DynamicPartitionAccessObject) String() string { return proto.CompactTextString(m) }
func (*DynamicPartitionAccessObject) ProtoMessage()    {}
func (*DynamicPartitionAccessObject) Descriptor() ([]byte, []int) {
	return fileDescriptorExplain, []int{4}
}

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" json:"indexes,omitempty"`
	Partitions []string       `protobuf:"bytes,4,rep,name=partitions" json:"partitions,omitempty"`
}

func (m *ScanAccessObject) Reset()                    { *m = ScanAccessObject{} }
func (m *ScanAccessObject) String() string            { return proto.CompactTextString(m) }
func (*ScanAccessObject) ProtoMessage()               {}
func (*ScanAccessObject) Descriptor() ([]byte, []int) { return fileDescriptorExplain, []int{5} }

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" json:"cols,omitempty"`
	IsClusteredIndex bool     `protobuf:"varint,3,opt,name=is_clustered_index,json=isClusteredIndex,proto3" json:"is_clustered_index,omitempty"`
}

func (m *IndexAccess) Reset()                    { *m = IndexAccess{} }
func (m *IndexAccess) String() string            { return proto.CompactTextString(m) }
func (*IndexAccess) ProtoMessage()               {}
func (*IndexAccess) Descriptor() ([]byte, []int) { return fileDescriptorExplain, []int{6} }

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.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")
	proto.RegisterEnum("tipb.TaskType", TaskType_name, TaskType_value)
	proto.RegisterEnum("tipb.StoreType", StoreType_name, StoreType_value)
	proto.RegisterEnum("tipb.OperatorLabel", OperatorLabel_name, OperatorLabel_value)
}
func (m *ExplainData) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ExplainData) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Main != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintExplain(dAtA, i, uint64(m.Main.Size()))
		n1, err := m.Main.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if len(m.Ctes) > 0 {
		for _, msg := range m.Ctes {
			dAtA[i] = 0x12
			i++
			i = encodeVarintExplain(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.WithRuntimeStats {
		dAtA[i] = 0x18
		i++
		if m.WithRuntimeStats {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.DiscardedDueToTooLong {
		dAtA[i] = 0x20
		i++
		if m.DiscardedDueToTooLong {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

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

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

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

func (m *AccessObject) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.AccessObject != nil {
		nn4, err := m.AccessObject.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn4
	}
	return i, nil
}

func (m *AccessObject_ScanObject) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ScanObject != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintExplain(dAtA, i, uint64(m.ScanObject.Size()))
		n5, err := m.ScanObject.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	return i, nil
}
func (m *AccessObject_DynamicPartitionObjects) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.DynamicPartitionObjects != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintExplain(dAtA, i, uint64(m.DynamicPartitionObjects.Size()))
		n6, err := m.DynamicPartitionObjects.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	return i, nil
}
func (m *AccessObject_OtherObject) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	dAtA[i] = 0x1a
	i++
	i = encodeVarintExplain(dAtA, i, uint64(len(m.OtherObject)))
	i += copy(dAtA[i:], m.OtherObject)
	return i, nil
}
func (m *DynamicPartitionAccessObjects) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DynamicPartitionAccessObjects) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Objects) > 0 {
		for _, msg := range m.Objects {
			dAtA[i] = 0xa
			i++
			i = encodeVarintExplain(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

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

func (m *DynamicPartitionAccessObject) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Database) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintExplain(dAtA, i, uint64(len(m.Database)))
		i += copy(dAtA[i:], m.Database)
	}
	if len(m.Table) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintExplain(dAtA, i, uint64(len(m.Table)))
		i += copy(dAtA[i:], m.Table)
	}
	if m.AllPartitions {
		dAtA[i] = 0x18
		i++
		if m.AllPartitions {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.Partitions) > 0 {
		for _, s := range m.Partitions {
			dAtA[i] = 0x22
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	return i, nil
}

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

func (m *ScanAccessObject) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Database) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintExplain(dAtA, i, uint64(len(m.Database)))
		i += copy(dAtA[i:], m.Database)
	}
	if len(m.Table) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintExplain(dAtA, i, uint64(len(m.Table)))
		i += copy(dAtA[i:], m.Table)
	}
	if len(m.Indexes) > 0 {
		for _, msg := range m.Indexes {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintExplain(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Partitions) > 0 {
		for _, s := range m.Partitions {
			dAtA[i] = 0x22
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	return i, nil
}

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

func (m *IndexAccess) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintExplain(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.Cols) > 0 {
		for _, s := range m.Cols {
			dAtA[i] = 0x12
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if m.IsClusteredIndex {
		dAtA[i] = 0x18
		i++
		if m.IsClusteredIndex {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

func encodeVarintExplain(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *ExplainData) Size() (n int) {
	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
	}
	return n
}

func (m *ExplainOperator) Size() (n int) {
	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))
	}
	return n
}

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

func (m *AccessObject_ScanObject) Size() (n int) {
	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) {
	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) {
	var l int
	_ = l
	l = len(m.OtherObject)
	n += 1 + l + sovExplain(uint64(l))
	return n
}
func (m *DynamicPartitionAccessObjects) Size() (n int) {
	var l int
	_ = l
	if len(m.Objects) > 0 {
		for _, e := range m.Objects {
			l = e.Size()
			n += 1 + l + sovExplain(uint64(l))
		}
	}
	return n
}

func (m *DynamicPartitionAccessObject) Size() (n int) {
	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))
		}
	}
	return n
}

func (m *ScanAccessObject) Size() (n int) {
	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))
		}
	}
	return n
}

func (m *IndexAccess) Size() (n int) {
	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
	}
	return n
}

func sovExplain(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
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 > 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 > 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 {
				return ErrInvalidLengthExplain
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 > 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 > 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 > l {
					return io.ErrUnexpectedEOF
				}
				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 > 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 > 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 > 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 > 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 > 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 {
				return ErrInvalidLengthExplain
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 > 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 > 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 > 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 {
				return ErrInvalidLengthExplain
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 > 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 {
				return ErrInvalidLengthExplain
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 > 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 > 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 > 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 {
				return ErrInvalidLengthExplain
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 > 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 > 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 > 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 > 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 {
				return ErrInvalidLengthExplain
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 > 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 > 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 {
				return ErrInvalidLengthExplain
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipExplain(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 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
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		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
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthExplain
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowExplain
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipExplain(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthExplain = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowExplain   = fmt.Errorf("proto: integer overflow")
)

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

var fileDescriptorExplain = []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,
}