github.com/cockroachdb/cockroach@v20.2.0-alpha.1+incompatible/pkg/sql/sqlbase/structured.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: sql/sqlbase/structured.proto

package sqlbase

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import geoindex "github.com/cockroachdb/cockroach/pkg/geo/geoindex"
import types "github.com/cockroachdb/cockroach/pkg/sql/types"
import hlc "github.com/cockroachdb/cockroach/pkg/util/hlc"

import github_com_cockroachdb_cockroach_pkg_roachpb "github.com/cockroachdb/cockroach/pkg/roachpb"

import bytes "bytes"

import io "io"

import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"

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

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

type ConstraintValidity int32

const (
	// The constraint is valid for all rows.
	ConstraintValidity_Validated ConstraintValidity = 0
	// The constraint has not yet been validated for all rows (and will not be
	// validated until VALIDATE CONSTRAINT is used).
	ConstraintValidity_Unvalidated ConstraintValidity = 1
	// The constraint was just added, but the validation for existing rows is not
	// yet complete. If validation fails, the constraint will be dropped.
	ConstraintValidity_Validating ConstraintValidity = 2
	// The constraint is being dropped in the schema changer.
	ConstraintValidity_Dropping ConstraintValidity = 3
)

var ConstraintValidity_name = map[int32]string{
	0: "Validated",
	1: "Unvalidated",
	2: "Validating",
	3: "Dropping",
}
var ConstraintValidity_value = map[string]int32{
	"Validated":   0,
	"Unvalidated": 1,
	"Validating":  2,
	"Dropping":    3,
}

func (x ConstraintValidity) Enum() *ConstraintValidity {
	p := new(ConstraintValidity)
	*p = x
	return p
}
func (x ConstraintValidity) String() string {
	return proto.EnumName(ConstraintValidity_name, int32(x))
}
func (x *ConstraintValidity) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ConstraintValidity_value, data, "ConstraintValidity")
	if err != nil {
		return err
	}
	*x = ConstraintValidity(value)
	return nil
}
func (ConstraintValidity) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{0}
}

type ForeignKeyReference_Action int32

const (
	ForeignKeyReference_NO_ACTION   ForeignKeyReference_Action = 0
	ForeignKeyReference_RESTRICT    ForeignKeyReference_Action = 1
	ForeignKeyReference_SET_NULL    ForeignKeyReference_Action = 2
	ForeignKeyReference_SET_DEFAULT ForeignKeyReference_Action = 3
	ForeignKeyReference_CASCADE     ForeignKeyReference_Action = 4
)

var ForeignKeyReference_Action_name = map[int32]string{
	0: "NO_ACTION",
	1: "RESTRICT",
	2: "SET_NULL",
	3: "SET_DEFAULT",
	4: "CASCADE",
}
var ForeignKeyReference_Action_value = map[string]int32{
	"NO_ACTION":   0,
	"RESTRICT":    1,
	"SET_NULL":    2,
	"SET_DEFAULT": 3,
	"CASCADE":     4,
}

func (x ForeignKeyReference_Action) Enum() *ForeignKeyReference_Action {
	p := new(ForeignKeyReference_Action)
	*p = x
	return p
}
func (x ForeignKeyReference_Action) MarshalJSON() ([]byte, error) {
	return proto.MarshalJSONEnum(ForeignKeyReference_Action_name, int32(x))
}
func (x *ForeignKeyReference_Action) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ForeignKeyReference_Action_value, data, "ForeignKeyReference_Action")
	if err != nil {
		return err
	}
	*x = ForeignKeyReference_Action(value)
	return nil
}
func (ForeignKeyReference_Action) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{0, 0}
}

// Match is the algorithm used to compare composite keys.
type ForeignKeyReference_Match int32

const (
	ForeignKeyReference_SIMPLE  ForeignKeyReference_Match = 0
	ForeignKeyReference_FULL    ForeignKeyReference_Match = 1
	ForeignKeyReference_PARTIAL ForeignKeyReference_Match = 2
)

var ForeignKeyReference_Match_name = map[int32]string{
	0: "SIMPLE",
	1: "FULL",
	2: "PARTIAL",
}
var ForeignKeyReference_Match_value = map[string]int32{
	"SIMPLE":  0,
	"FULL":    1,
	"PARTIAL": 2,
}

func (x ForeignKeyReference_Match) Enum() *ForeignKeyReference_Match {
	p := new(ForeignKeyReference_Match)
	*p = x
	return p
}
func (x ForeignKeyReference_Match) MarshalJSON() ([]byte, error) {
	return proto.MarshalJSONEnum(ForeignKeyReference_Match_name, int32(x))
}
func (x *ForeignKeyReference_Match) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ForeignKeyReference_Match_value, data, "ForeignKeyReference_Match")
	if err != nil {
		return err
	}
	*x = ForeignKeyReference_Match(value)
	return nil
}
func (ForeignKeyReference_Match) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{0, 1}
}

// The direction of a column in the index.
type IndexDescriptor_Direction int32

const (
	IndexDescriptor_ASC  IndexDescriptor_Direction = 0
	IndexDescriptor_DESC IndexDescriptor_Direction = 1
)

var IndexDescriptor_Direction_name = map[int32]string{
	0: "ASC",
	1: "DESC",
}
var IndexDescriptor_Direction_value = map[string]int32{
	"ASC":  0,
	"DESC": 1,
}

func (x IndexDescriptor_Direction) Enum() *IndexDescriptor_Direction {
	p := new(IndexDescriptor_Direction)
	*p = x
	return p
}
func (x IndexDescriptor_Direction) String() string {
	return proto.EnumName(IndexDescriptor_Direction_name, int32(x))
}
func (x *IndexDescriptor_Direction) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(IndexDescriptor_Direction_value, data, "IndexDescriptor_Direction")
	if err != nil {
		return err
	}
	*x = IndexDescriptor_Direction(value)
	return nil
}
func (IndexDescriptor_Direction) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{7, 0}
}

// The type of the index.
type IndexDescriptor_Type int32

const (
	IndexDescriptor_FORWARD  IndexDescriptor_Type = 0
	IndexDescriptor_INVERTED IndexDescriptor_Type = 1
)

var IndexDescriptor_Type_name = map[int32]string{
	0: "FORWARD",
	1: "INVERTED",
}
var IndexDescriptor_Type_value = map[string]int32{
	"FORWARD":  0,
	"INVERTED": 1,
}

func (x IndexDescriptor_Type) Enum() *IndexDescriptor_Type {
	p := new(IndexDescriptor_Type)
	*p = x
	return p
}
func (x IndexDescriptor_Type) String() string {
	return proto.EnumName(IndexDescriptor_Type_name, int32(x))
}
func (x *IndexDescriptor_Type) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(IndexDescriptor_Type_value, data, "IndexDescriptor_Type")
	if err != nil {
		return err
	}
	*x = IndexDescriptor_Type(value)
	return nil
}
func (IndexDescriptor_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{7, 1}
}

type ConstraintToUpdate_ConstraintType int32

const (
	ConstraintToUpdate_CHECK       ConstraintToUpdate_ConstraintType = 0
	ConstraintToUpdate_FOREIGN_KEY ConstraintToUpdate_ConstraintType = 1
	// NOT NULL constraints being added are represented by a dummy check
	// constraint so that a multi-state schema change, including a bulk
	// validation step, can occur. The check field contains the dummy
	// constraint.
	ConstraintToUpdate_NOT_NULL ConstraintToUpdate_ConstraintType = 2
)

var ConstraintToUpdate_ConstraintType_name = map[int32]string{
	0: "CHECK",
	1: "FOREIGN_KEY",
	2: "NOT_NULL",
}
var ConstraintToUpdate_ConstraintType_value = map[string]int32{
	"CHECK":       0,
	"FOREIGN_KEY": 1,
	"NOT_NULL":    2,
}

func (x ConstraintToUpdate_ConstraintType) Enum() *ConstraintToUpdate_ConstraintType {
	p := new(ConstraintToUpdate_ConstraintType)
	*p = x
	return p
}
func (x ConstraintToUpdate_ConstraintType) String() string {
	return proto.EnumName(ConstraintToUpdate_ConstraintType_name, int32(x))
}
func (x *ConstraintToUpdate_ConstraintType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ConstraintToUpdate_ConstraintType_value, data, "ConstraintToUpdate_ConstraintType")
	if err != nil {
		return err
	}
	*x = ConstraintToUpdate_ConstraintType(value)
	return nil
}
func (ConstraintToUpdate_ConstraintType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{8, 0}
}

// A descriptor within a mutation is unavailable for reads, writes
// and deletes. It is only available for implicit (internal to
// the database) writes and deletes depending on the state of the mutation.
type DescriptorMutation_State int32

const (
	// Not used.
	DescriptorMutation_UNKNOWN DescriptorMutation_State = 0
	// Operations can use this invisible descriptor to implicitly
	// delete entries.
	// Column: A descriptor in this state is invisible to
	// INSERT and UPDATE. DELETE must delete a column in this state.
	// Index: A descriptor in this state is invisible to an INSERT.
	// UPDATE must delete the old value of the index but doesn't write
	// the new value. DELETE must delete the index.
	//
	// When deleting a descriptor, all descriptor related data
	// (column or index data) can only be mass deleted once
	// all the nodes have transitioned to the DELETE_ONLY state.
	DescriptorMutation_DELETE_ONLY DescriptorMutation_State = 1
	// Operations can use this invisible descriptor to implicitly
	// write and delete entries.
	// Column: INSERT will populate this column with the default
	// value. UPDATE ignores this descriptor. DELETE must delete
	// the column.
	// Index: INSERT, UPDATE and DELETE treat this index like any
	// other index.
	//
	// When adding a descriptor, all descriptor related data
	// (column default or index data) can only be backfilled once
	// all nodes have transitioned into the DELETE_AND_WRITE_ONLY state.
	DescriptorMutation_DELETE_AND_WRITE_ONLY DescriptorMutation_State = 2
)

var DescriptorMutation_State_name = map[int32]string{
	0: "UNKNOWN",
	1: "DELETE_ONLY",
	2: "DELETE_AND_WRITE_ONLY",
}
var DescriptorMutation_State_value = map[string]int32{
	"UNKNOWN":               0,
	"DELETE_ONLY":           1,
	"DELETE_AND_WRITE_ONLY": 2,
}

func (x DescriptorMutation_State) Enum() *DescriptorMutation_State {
	p := new(DescriptorMutation_State)
	*p = x
	return p
}
func (x DescriptorMutation_State) String() string {
	return proto.EnumName(DescriptorMutation_State_name, int32(x))
}
func (x *DescriptorMutation_State) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(DescriptorMutation_State_value, data, "DescriptorMutation_State")
	if err != nil {
		return err
	}
	*x = DescriptorMutation_State(value)
	return nil
}
func (DescriptorMutation_State) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{11, 0}
}

// Direction of mutation.
type DescriptorMutation_Direction int32

const (
	// Not used.
	DescriptorMutation_NONE DescriptorMutation_Direction = 0
	// Descriptor is being added.
	DescriptorMutation_ADD DescriptorMutation_Direction = 1
	// Descriptor is being dropped.
	DescriptorMutation_DROP DescriptorMutation_Direction = 2
)

var DescriptorMutation_Direction_name = map[int32]string{
	0: "NONE",
	1: "ADD",
	2: "DROP",
}
var DescriptorMutation_Direction_value = map[string]int32{
	"NONE": 0,
	"ADD":  1,
	"DROP": 2,
}

func (x DescriptorMutation_Direction) Enum() *DescriptorMutation_Direction {
	p := new(DescriptorMutation_Direction)
	*p = x
	return p
}
func (x DescriptorMutation_Direction) String() string {
	return proto.EnumName(DescriptorMutation_Direction_name, int32(x))
}
func (x *DescriptorMutation_Direction) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(DescriptorMutation_Direction_value, data, "DescriptorMutation_Direction")
	if err != nil {
		return err
	}
	*x = DescriptorMutation_Direction(value)
	return nil
}
func (DescriptorMutation_Direction) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{11, 1}
}

// State is set if this TableDescriptor is in the process of being added or deleted.
// A non-public table descriptor cannot be leased.
// A schema changer observing DROP set will truncate the table and delete the
// descriptor.
// It is illegal to transition DROP to any other state.
type TableDescriptor_State int32

const (
	// Not used.
	TableDescriptor_PUBLIC TableDescriptor_State = 0
	// Descriptor is being added.
	TableDescriptor_ADD TableDescriptor_State = 1
	// Descriptor is being dropped.
	TableDescriptor_DROP TableDescriptor_State = 2
	// Descriptor is offline (e.g. for bulk-ingestion). See offline_reason.
	TableDescriptor_OFFLINE TableDescriptor_State = 3
)

var TableDescriptor_State_name = map[int32]string{
	0: "PUBLIC",
	1: "ADD",
	2: "DROP",
	3: "OFFLINE",
}
var TableDescriptor_State_value = map[string]int32{
	"PUBLIC":  0,
	"ADD":     1,
	"DROP":    2,
	"OFFLINE": 3,
}

func (x TableDescriptor_State) Enum() *TableDescriptor_State {
	p := new(TableDescriptor_State)
	*p = x
	return p
}
func (x TableDescriptor_State) String() string {
	return proto.EnumName(TableDescriptor_State_name, int32(x))
}
func (x *TableDescriptor_State) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(TableDescriptor_State_value, data, "TableDescriptor_State")
	if err != nil {
		return err
	}
	*x = TableDescriptor_State(value)
	return nil
}
func (TableDescriptor_State) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{12, 0}
}

// AuditMode indicates which auditing actions to take when this table is used.
type TableDescriptor_AuditMode int32

const (
	TableDescriptor_DISABLED  TableDescriptor_AuditMode = 0
	TableDescriptor_READWRITE TableDescriptor_AuditMode = 1
)

var TableDescriptor_AuditMode_name = map[int32]string{
	0: "DISABLED",
	1: "READWRITE",
}
var TableDescriptor_AuditMode_value = map[string]int32{
	"DISABLED":  0,
	"READWRITE": 1,
}

func (x TableDescriptor_AuditMode) Enum() *TableDescriptor_AuditMode {
	p := new(TableDescriptor_AuditMode)
	*p = x
	return p
}
func (x TableDescriptor_AuditMode) String() string {
	return proto.EnumName(TableDescriptor_AuditMode_name, int32(x))
}
func (x *TableDescriptor_AuditMode) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(TableDescriptor_AuditMode_value, data, "TableDescriptor_AuditMode")
	if err != nil {
		return err
	}
	*x = TableDescriptor_AuditMode(value)
	return nil
}
func (TableDescriptor_AuditMode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{12, 1}
}

// Represents the kind of type that this type descriptor represents.
type TypeDescriptor_Kind int32

const (
	// Represents a user defined enum type.
	TypeDescriptor_ENUM TypeDescriptor_Kind = 0
	// Represents a user defined type that is just an alias for another type.
	// As of now, it is used only internally.
	TypeDescriptor_ALIAS TypeDescriptor_Kind = 1
)

var TypeDescriptor_Kind_name = map[int32]string{
	0: "ENUM",
	1: "ALIAS",
}
var TypeDescriptor_Kind_value = map[string]int32{
	"ENUM":  0,
	"ALIAS": 1,
}

func (x TypeDescriptor_Kind) Enum() *TypeDescriptor_Kind {
	p := new(TypeDescriptor_Kind)
	*p = x
	return p
}
func (x TypeDescriptor_Kind) String() string {
	return proto.EnumName(TypeDescriptor_Kind_name, int32(x))
}
func (x *TypeDescriptor_Kind) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(TypeDescriptor_Kind_value, data, "TypeDescriptor_Kind")
	if err != nil {
		return err
	}
	*x = TypeDescriptor_Kind(value)
	return nil
}
func (TypeDescriptor_Kind) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{14, 0}
}

// ForeignKeyReference is deprecated, replaced by ForeignKeyConstraint in v19.2
// (though it is still possible for table descriptors on disk to have
// ForeignKeyReferences).
//
// It is still used to describe interleavings (see
// IndexDescriptor.InterleavedBy), for which it is a poor choice: only the Table
// and Index fields are used, and the interleaving has nothing to do with
// traditional foreign key references.
type ForeignKeyReference struct {
	Table    ID                 `protobuf:"varint,1,opt,name=table,casttype=ID" json:"table"`
	Index    IndexID            `protobuf:"varint,2,opt,name=index,casttype=IndexID" json:"index"`
	Name     string             `protobuf:"bytes,3,opt,name=name" json:"name"`
	Validity ConstraintValidity `protobuf:"varint,4,opt,name=validity,enum=cockroach.sql.sqlbase.ConstraintValidity" json:"validity"`
	// If this FK only uses a prefix of the columns in its index, we record how
	// many to avoid spuriously counting the additional cols as used by this FK.
	SharedPrefixLen int32                      `protobuf:"varint,5,opt,name=shared_prefix_len,json=sharedPrefixLen" json:"shared_prefix_len"`
	OnDelete        ForeignKeyReference_Action `protobuf:"varint,6,opt,name=on_delete,json=onDelete,enum=cockroach.sql.sqlbase.ForeignKeyReference_Action" json:"on_delete"`
	OnUpdate        ForeignKeyReference_Action `protobuf:"varint,7,opt,name=on_update,json=onUpdate,enum=cockroach.sql.sqlbase.ForeignKeyReference_Action" json:"on_update"`
	// This is only important for composite keys. For all prior matches before
	// the addition of this value, MATCH SIMPLE will be used.
	Match ForeignKeyReference_Match `protobuf:"varint,8,opt,name=match,enum=cockroach.sql.sqlbase.ForeignKeyReference_Match" json:"match"`
}

func (m *ForeignKeyReference) Reset()         { *m = ForeignKeyReference{} }
func (m *ForeignKeyReference) String() string { return proto.CompactTextString(m) }
func (*ForeignKeyReference) ProtoMessage()    {}
func (*ForeignKeyReference) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{0}
}
func (m *ForeignKeyReference) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ForeignKeyReference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *ForeignKeyReference) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ForeignKeyReference.Merge(dst, src)
}
func (m *ForeignKeyReference) XXX_Size() int {
	return m.Size()
}
func (m *ForeignKeyReference) XXX_DiscardUnknown() {
	xxx_messageInfo_ForeignKeyReference.DiscardUnknown(m)
}

var xxx_messageInfo_ForeignKeyReference proto.InternalMessageInfo

// ForeignKeyConstraint is the new (as of 19.2 and VersionTopLevelForeignKeys)
// representation for foreign keys. It's stored on the TableDescriptor and is
// designed to be agnostic to which indexes are available on both the origin
// and referenced tables, so that the optimizer can have full freedom to choose
// the best possible index to satisfy constraint checks at runtime.
type ForeignKeyConstraint struct {
	OriginTableID       ID                         `protobuf:"varint,1,opt,name=origin_table_id,json=originTableId,casttype=ID" json:"origin_table_id"`
	OriginColumnIDs     []ColumnID                 `protobuf:"varint,2,rep,name=origin_column_ids,json=originColumnIds,casttype=ColumnID" json:"origin_column_ids,omitempty"`
	ReferencedColumnIDs []ColumnID                 `protobuf:"varint,3,rep,name=referenced_column_ids,json=referencedColumnIds,casttype=ColumnID" json:"referenced_column_ids,omitempty"`
	ReferencedTableID   ID                         `protobuf:"varint,4,opt,name=referenced_table_id,json=referencedTableId,casttype=ID" json:"referenced_table_id"`
	Name                string                     `protobuf:"bytes,5,opt,name=name" json:"name"`
	Validity            ConstraintValidity         `protobuf:"varint,6,opt,name=validity,enum=cockroach.sql.sqlbase.ConstraintValidity" json:"validity"`
	OnDelete            ForeignKeyReference_Action `protobuf:"varint,7,opt,name=on_delete,json=onDelete,enum=cockroach.sql.sqlbase.ForeignKeyReference_Action" json:"on_delete"`
	OnUpdate            ForeignKeyReference_Action `protobuf:"varint,8,opt,name=on_update,json=onUpdate,enum=cockroach.sql.sqlbase.ForeignKeyReference_Action" json:"on_update"`
	// This is only important for composite keys. For all prior matches before
	// the addition of this value, MATCH SIMPLE will be used.
	Match ForeignKeyReference_Match `protobuf:"varint,9,opt,name=match,enum=cockroach.sql.sqlbase.ForeignKeyReference_Match" json:"match"`
	// LegacyOriginIndex is the ID of the index used for the FK on the origin
	// table. In versions 19.1 and earlier, foreign keys were represented by
	// fields on the index that they use. In versions 19.2 and later, we preserve
	// the semantics of the older FKs which were tied to indexes by specifying
	// the index as a field on this proto, since the migration process to have
	// top-level FK fields on the table descriptor requires two releases.
	// In 20.1, these fields are no longer read, but must continue to be written
	// to maintain compatibility in mixed 19.2/20.1 clusters. In 20.2 these fields
	// can _finally_ be removed.
	// * When using the foreign key constraint, do not read from these fields! *
	LegacyOriginIndex IndexID `protobuf:"varint,10,opt,name=legacy_origin_index,json=legacyOriginIndex,casttype=IndexID" json:"legacy_origin_index"` // Deprecated: Do not use.
	// LegacyReferencedIndex is the ID of the index used for the FK on the
	// referenced side. See the comment for LegacyOriginIndex.
	LegacyReferencedIndex IndexID `protobuf:"varint,11,opt,name=legacy_referenced_index,json=legacyReferencedIndex,casttype=IndexID" json:"legacy_referenced_index"` // Deprecated: Do not use.
}

func (m *ForeignKeyConstraint) Reset()         { *m = ForeignKeyConstraint{} }
func (m *ForeignKeyConstraint) String() string { return proto.CompactTextString(m) }
func (*ForeignKeyConstraint) ProtoMessage()    {}
func (*ForeignKeyConstraint) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{1}
}
func (m *ForeignKeyConstraint) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ForeignKeyConstraint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *ForeignKeyConstraint) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ForeignKeyConstraint.Merge(dst, src)
}
func (m *ForeignKeyConstraint) XXX_Size() int {
	return m.Size()
}
func (m *ForeignKeyConstraint) XXX_DiscardUnknown() {
	xxx_messageInfo_ForeignKeyConstraint.DiscardUnknown(m)
}

var xxx_messageInfo_ForeignKeyConstraint proto.InternalMessageInfo

type ColumnDescriptor struct {
	Name     string   `protobuf:"bytes,1,opt,name=name" json:"name"`
	ID       ColumnID `protobuf:"varint,2,opt,name=id,casttype=ColumnID" json:"id"`
	Type     *types.T `protobuf:"bytes,3,opt,name=type" json:"type,omitempty"`
	Nullable bool     `protobuf:"varint,4,opt,name=nullable" json:"nullable"`
	// Default expression to use to populate the column on insert if no
	// value is provided. Note that it is not correct to use DefaultExpr
	// as output to display to a user. User defined types within DefaultExpr
	// have been serialized in a internal format. Instead, format the result
	// of DeserializeTableDescExpr.
	DefaultExpr *string `protobuf:"bytes,5,opt,name=default_expr,json=defaultExpr" json:"default_expr,omitempty"`
	Hidden      bool    `protobuf:"varint,6,opt,name=hidden" json:"hidden"`
	// Ids of sequences used in this column's DEFAULT expression, in calls to nextval().
	UsesSequenceIds []ID `protobuf:"varint,10,rep,name=uses_sequence_ids,json=usesSequenceIds,casttype=ID" json:"uses_sequence_ids,omitempty"`
	// Ids of sequences that the column owns.
	OwnsSequenceIds []ID `protobuf:"varint,12,rep,name=owns_sequence_ids,json=ownsSequenceIds,casttype=ID" json:"owns_sequence_ids,omitempty"`
	// Expression to use to compute the value of this column if this is a
	// computed column. Note that it is not correct to use ComputeExpr
	// as output to display to a user. User defined types within ComputeExpr
	// have been serialized in a internal format. Instead, format the result
	// of DeserializeTableDescExpr.
	ComputeExpr *string `protobuf:"bytes,11,opt,name=compute_expr,json=computeExpr" json:"compute_expr,omitempty"`
	// LogicalColumnID must be accessed through the accessor, since it is set
	// lazily, it is incorrect to access it directly.
	// LogicalColumnID represents a column's number in catalog tables.
	// This only differs from ID when the Column order is swapped or
	// the ColumnDescriptor must be remade while remaining visual ordering.
	// This does not exist in TableDescriptors pre 20.2.
	LogicalColumnID ColumnID `protobuf:"varint,13,opt,name=logical_id,json=logicalId,casttype=ColumnID" json:"logical_id"`
	// Used to indicate column is used and dropped for ALTER COLUMN TYPE mutation.
	AlterColumnTypeInProgress bool `protobuf:"varint,14,opt,name=alter_column_type_in_progress,json=alterColumnTypeInProgress" json:"alter_column_type_in_progress"`
}

func (m *ColumnDescriptor) Reset()         { *m = ColumnDescriptor{} }
func (m *ColumnDescriptor) String() string { return proto.CompactTextString(m) }
func (*ColumnDescriptor) ProtoMessage()    {}
func (*ColumnDescriptor) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{2}
}
func (m *ColumnDescriptor) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ColumnDescriptor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *ColumnDescriptor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ColumnDescriptor.Merge(dst, src)
}
func (m *ColumnDescriptor) XXX_Size() int {
	return m.Size()
}
func (m *ColumnDescriptor) XXX_DiscardUnknown() {
	xxx_messageInfo_ColumnDescriptor.DiscardUnknown(m)
}

var xxx_messageInfo_ColumnDescriptor proto.InternalMessageInfo

// ColumnFamilyDescriptor is set of columns stored together in one kv entry.
// For more information, look at `docs/tech-notes/encoding.md#value-encoding`.
type ColumnFamilyDescriptor struct {
	Name string `protobuf:"bytes,1,opt,name=name" json:"name"`
	// Column family 0 is *always* included in k/v pairs for a row. This makes
	// sure that rows will all NULL values still have a k/v pair. When performing
	// optimizations involving column families, ensure that column family 0
	// is scanned if the row may have nulls.
	ID FamilyID `protobuf:"varint,2,opt,name=id,casttype=FamilyID" json:"id"`
	// A list of column names of which the family is comprised. This list
	// parallels the column_ids list. If duplicating the storage of the column
	// names here proves to be prohibitive, we could clear this field before
	// saving and reconstruct it after loading.
	ColumnNames []string `protobuf:"bytes,3,rep,name=column_names,json=columnNames" json:"column_names,omitempty"`
	// A list of column ids of which the family is comprised. This list parallels
	// the column_names list.
	ColumnIDs []ColumnID `protobuf:"varint,4,rep,name=column_ids,json=columnIds,casttype=ColumnID" json:"column_ids,omitempty"`
	// If nonzero, the column involved in the single column optimization.
	//
	// Families store columns in a ValueType_TUPLE as repeated <columnID><data>
	// entries. As a space optimization and for backward compatibility, a single
	// column is written without the column id prefix. Because more columns could
	// be added, it would be ambiguous which column was stored when read back in,
	// so this field supplies it.
	DefaultColumnID ColumnID `protobuf:"varint,5,opt,name=default_column_id,json=defaultColumnId,casttype=ColumnID" json:"default_column_id"`
}

func (m *ColumnFamilyDescriptor) Reset()         { *m = ColumnFamilyDescriptor{} }
func (m *ColumnFamilyDescriptor) String() string { return proto.CompactTextString(m) }
func (*ColumnFamilyDescriptor) ProtoMessage()    {}
func (*ColumnFamilyDescriptor) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{3}
}
func (m *ColumnFamilyDescriptor) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ColumnFamilyDescriptor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *ColumnFamilyDescriptor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ColumnFamilyDescriptor.Merge(dst, src)
}
func (m *ColumnFamilyDescriptor) XXX_Size() int {
	return m.Size()
}
func (m *ColumnFamilyDescriptor) XXX_DiscardUnknown() {
	xxx_messageInfo_ColumnFamilyDescriptor.DiscardUnknown(m)
}

var xxx_messageInfo_ColumnFamilyDescriptor proto.InternalMessageInfo

// InterleaveDescriptor represents an index (either primary or secondary) that
// is interleaved into another table's data.
//
// Example:
// Table 1 -> /a/b
// Table 2 -> /a/b/c
// Table 3 -> /a/b/c/d
//
// There are two components (table 2 is the parent and table 1 is the
// grandparent) with shared lengths 2 and 1.
type InterleaveDescriptor struct {
	// Ancestors contains the nesting of interleaves in the order they appear in
	// an encoded key. This means they are always in the far-to-near ancestor
	// order (e.g. grand-grand-parent, grand-parent, parent).
	Ancestors []InterleaveDescriptor_Ancestor `protobuf:"bytes,1,rep,name=ancestors" json:"ancestors"`
}

func (m *InterleaveDescriptor) Reset()         { *m = InterleaveDescriptor{} }
func (m *InterleaveDescriptor) String() string { return proto.CompactTextString(m) }
func (*InterleaveDescriptor) ProtoMessage()    {}
func (*InterleaveDescriptor) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{4}
}
func (m *InterleaveDescriptor) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InterleaveDescriptor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *InterleaveDescriptor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InterleaveDescriptor.Merge(dst, src)
}
func (m *InterleaveDescriptor) XXX_Size() int {
	return m.Size()
}
func (m *InterleaveDescriptor) XXX_DiscardUnknown() {
	xxx_messageInfo_InterleaveDescriptor.DiscardUnknown(m)
}

var xxx_messageInfo_InterleaveDescriptor proto.InternalMessageInfo

type InterleaveDescriptor_Ancestor struct {
	// TableID is the ID of the table being interleaved into.
	TableID ID `protobuf:"varint,1,opt,name=table_id,json=tableId,casttype=ID" json:"table_id"`
	// IndexID is the ID of the parent index being interleaved into.
	IndexID IndexID `protobuf:"varint,2,opt,name=index_id,json=indexId,casttype=IndexID" json:"index_id"`
	// SharedPrefixLen is how many fields are shared between a parent and child
	// being interleaved, excluding any fields shared between parent and
	// grandparent. Thus, the sum of SharedPrefixLens in the components of an
	// InterleaveDescriptor is never more than the number of fields in the index
	// being interleaved.
	// In cockroach 1.0, this value did not exist and thus a check for > 0
	// must be performed prior to its use.
	SharedPrefixLen uint32 `protobuf:"varint,3,opt,name=shared_prefix_len,json=sharedPrefixLen" json:"shared_prefix_len"`
}

func (m *InterleaveDescriptor_Ancestor) Reset()         { *m = InterleaveDescriptor_Ancestor{} }
func (m *InterleaveDescriptor_Ancestor) String() string { return proto.CompactTextString(m) }
func (*InterleaveDescriptor_Ancestor) ProtoMessage()    {}
func (*InterleaveDescriptor_Ancestor) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{4, 0}
}
func (m *InterleaveDescriptor_Ancestor) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InterleaveDescriptor_Ancestor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *InterleaveDescriptor_Ancestor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InterleaveDescriptor_Ancestor.Merge(dst, src)
}
func (m *InterleaveDescriptor_Ancestor) XXX_Size() int {
	return m.Size()
}
func (m *InterleaveDescriptor_Ancestor) XXX_DiscardUnknown() {
	xxx_messageInfo_InterleaveDescriptor_Ancestor.DiscardUnknown(m)
}

var xxx_messageInfo_InterleaveDescriptor_Ancestor proto.InternalMessageInfo

// ShardedDescriptor represents an index (either primary or secondary) that is hash
// sharded into a user-specified number of buckets.
//
// As as example, sample field values for the following table:
//
// CREATE TABLE abc (
//   a INT PRIMARY KEY USING HASH WITH BUCKET_COUNT=10,  // column id: 1
//   b BYTES
// );
//
// Sharded descriptor:
//   name:          "a_shard"
//   shard_buckets: 10
//   column_names:  ["a"]
type ShardedDescriptor struct {
	// IsSharded indicates whether the index in question is a sharded one.
	IsSharded bool `protobuf:"varint,1,opt,name=is_sharded,json=isSharded" json:"is_sharded"`
	// Name is the name of the shard column.
	Name string `protobuf:"bytes,2,opt,name=name" json:"name"`
	// ShardBuckets indicates the number of shards this index is divided into.
	ShardBuckets int32 `protobuf:"varint,3,opt,name=shard_buckets,json=shardBuckets" json:"shard_buckets"`
	// ColumnNames lists the names of the columns used to compute the shard column's
	// values.
	ColumnNames []string `protobuf:"bytes,4,rep,name=column_names,json=columnNames" json:"column_names,omitempty"`
}

func (m *ShardedDescriptor) Reset()         { *m = ShardedDescriptor{} }
func (m *ShardedDescriptor) String() string { return proto.CompactTextString(m) }
func (*ShardedDescriptor) ProtoMessage()    {}
func (*ShardedDescriptor) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{5}
}
func (m *ShardedDescriptor) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ShardedDescriptor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *ShardedDescriptor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShardedDescriptor.Merge(dst, src)
}
func (m *ShardedDescriptor) XXX_Size() int {
	return m.Size()
}
func (m *ShardedDescriptor) XXX_DiscardUnknown() {
	xxx_messageInfo_ShardedDescriptor.DiscardUnknown(m)
}

var xxx_messageInfo_ShardedDescriptor proto.InternalMessageInfo

// PartitioningDescriptor represents the partitioning of an index into spans
// of keys addressable by a zone config. The key encoding is unchanged. Each
// partition may optionally be itself divided into further partitions, called
// subpartitions.
type PartitioningDescriptor struct {
	// NumColumns is how large of a prefix of the columns in an index are used in
	// the function mapping column values to partitions. If this is a
	// subpartition, this is offset to start from the end of the parent
	// partition's columns. If NumColumns is 0, then there is no partitioning.
	NumColumns uint32 `protobuf:"varint,1,opt,name=num_columns,json=numColumns" json:"num_columns"`
	// Exactly one of List or Range is required to be non-empty if NumColumns is
	// non-zero.
	List  []PartitioningDescriptor_List  `protobuf:"bytes,2,rep,name=list" json:"list"`
	Range []PartitioningDescriptor_Range `protobuf:"bytes,3,rep,name=range" json:"range"`
}

func (m *PartitioningDescriptor) Reset()         { *m = PartitioningDescriptor{} }
func (m *PartitioningDescriptor) String() string { return proto.CompactTextString(m) }
func (*PartitioningDescriptor) ProtoMessage()    {}
func (*PartitioningDescriptor) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{6}
}
func (m *PartitioningDescriptor) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PartitioningDescriptor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *PartitioningDescriptor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PartitioningDescriptor.Merge(dst, src)
}
func (m *PartitioningDescriptor) XXX_Size() int {
	return m.Size()
}
func (m *PartitioningDescriptor) XXX_DiscardUnknown() {
	xxx_messageInfo_PartitioningDescriptor.DiscardUnknown(m)
}

var xxx_messageInfo_PartitioningDescriptor proto.InternalMessageInfo

// List represents a list partitioning, which maps individual tuples to
// partitions.
type PartitioningDescriptor_List struct {
	// Name is the partition name.
	Name string `protobuf:"bytes,1,opt,name=name" json:"name"`
	// Values is an unordered set of the tuples included in this partition. Each
	// tuple is encoded with the EncDatum value encoding. DEFAULT is encoded as
	// NOT NULL followed by PartitionDefaultVal encoded as a non-sorting
	// uvarint.
	Values [][]byte `protobuf:"bytes,2,rep,name=values" json:"values,omitempty"`
	// Subpartitioning represents a further partitioning of this list partition.
	Subpartitioning PartitioningDescriptor `protobuf:"bytes,3,opt,name=subpartitioning" json:"subpartitioning"`
}

func (m *PartitioningDescriptor_List) Reset()         { *m = PartitioningDescriptor_List{} }
func (m *PartitioningDescriptor_List) String() string { return proto.CompactTextString(m) }
func (*PartitioningDescriptor_List) ProtoMessage()    {}
func (*PartitioningDescriptor_List) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{6, 0}
}
func (m *PartitioningDescriptor_List) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PartitioningDescriptor_List) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *PartitioningDescriptor_List) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PartitioningDescriptor_List.Merge(dst, src)
}
func (m *PartitioningDescriptor_List) XXX_Size() int {
	return m.Size()
}
func (m *PartitioningDescriptor_List) XXX_DiscardUnknown() {
	xxx_messageInfo_PartitioningDescriptor_List.DiscardUnknown(m)
}

var xxx_messageInfo_PartitioningDescriptor_List proto.InternalMessageInfo

// Range represents a range partitioning, which maps ranges of tuples to
// partitions by specifying exclusive upper bounds. The range partitions in a
// PartitioningDescriptor are required to be sorted by UpperBound.
type PartitioningDescriptor_Range struct {
	// Name is the partition name.
	Name string `protobuf:"bytes,1,opt,name=name" json:"name"`
	// FromInclusive is the inclusive lower bound of this range partition. It is
	// encoded with the EncDatum value encoding. MINVALUE and MAXVALUE are
	// encoded as NOT NULL followed by a PartitionSpecialValCode encoded as a
	// non-sorting uvarint.
	FromInclusive []byte `protobuf:"bytes,3,opt,name=from_inclusive,json=fromInclusive" json:"from_inclusive,omitempty"`
	// ToExclusive is the exclusive upper bound of this range partition. It is
	// encoded in the same way as From.
	ToExclusive []byte `protobuf:"bytes,2,opt,name=to_exclusive,json=toExclusive" json:"to_exclusive,omitempty"`
}

func (m *PartitioningDescriptor_Range) Reset()         { *m = PartitioningDescriptor_Range{} }
func (m *PartitioningDescriptor_Range) String() string { return proto.CompactTextString(m) }
func (*PartitioningDescriptor_Range) ProtoMessage()    {}
func (*PartitioningDescriptor_Range) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{6, 1}
}
func (m *PartitioningDescriptor_Range) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PartitioningDescriptor_Range) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *PartitioningDescriptor_Range) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PartitioningDescriptor_Range.Merge(dst, src)
}
func (m *PartitioningDescriptor_Range) XXX_Size() int {
	return m.Size()
}
func (m *PartitioningDescriptor_Range) XXX_DiscardUnknown() {
	xxx_messageInfo_PartitioningDescriptor_Range.DiscardUnknown(m)
}

var xxx_messageInfo_PartitioningDescriptor_Range proto.InternalMessageInfo

// IndexDescriptor describes an index (primary or secondary).
//
// Sample field values on the following table:
//
//   CREATE TABLE t (
//     k1 INT NOT NULL,   // column ID: 1
//     k2 INT NOT NULL,   // column ID: 2
//     u INT NULL,        // column ID: 3
//     v INT NULL,        // column ID: 4
//     w INT NULL,        // column ID: 5
//     CONSTRAINT "primary" PRIMARY KEY (k1, k2),
//     INDEX k1v (k1, v) STORING (w),
//     FAMILY "primary" (k1, k2, u, v, w)
//   )
//
// Primary index:
//   name:                primary
//   id:                  1
//   unique:              true
//   column_names:        k1, k2
//   column_directions:   ASC, ASC
//   column_ids:          1, 2   // k1, k2
//
// [old STORING encoding] Index k1v (k1, v) STORING (w):
//   name:                k1v
//   id:                  2
//   unique:              false
//   column_names:        k1, v
//   column_directions:   ASC, ASC
//   store_column_names:  w
//   column_ids:          1, 4   // k1, v
//   extra_column_ids:    2, 5   // k2, w
//
// [new STORING encoding] Index k1v (k1, v) STORING (w):
//   name:                k1v
//   id:                  2
//   unique:              false
//   column_names:        k1, v
//   column_directions:   ASC, ASC
//   store_column_names:  w
//   column_ids:          1, 4   // k1, v
//   extra_column_ids:    2      // k2
//   store_column_ids:    5      // w
type IndexDescriptor struct {
	Name    string                 `protobuf:"bytes,1,opt,name=name" json:"name"`
	ID      IndexID                `protobuf:"varint,2,opt,name=id,casttype=IndexID" json:"id"`
	Unique  bool                   `protobuf:"varint,3,opt,name=unique" json:"unique"`
	Version IndexDescriptorVersion `protobuf:"varint,18,opt,name=version,casttype=IndexDescriptorVersion" json:"version"`
	// An ordered list of column names of which the index is comprised; these
	// columns do not include any additional stored columns (which are in
	// stored_column_names). This list parallels the column_ids list.
	//
	// Note: if duplicating the storage of the column names here proves to be
	// prohibitive, we could clear this field before saving and reconstruct it
	// after loading.
	ColumnNames []string `protobuf:"bytes,4,rep,name=column_names,json=columnNames" json:"column_names,omitempty"`
	// The sort direction of each column in column_names.
	ColumnDirections []IndexDescriptor_Direction `protobuf:"varint,8,rep,name=column_directions,json=columnDirections,enum=cockroach.sql.sqlbase.IndexDescriptor_Direction" json:"column_directions,omitempty"`
	// An ordered list of column names which the index stores in addition to the
	// columns which are explicitly part of the index (STORING clause). Only used
	// for secondary indexes.
	StoreColumnNames []string `protobuf:"bytes,5,rep,name=store_column_names,json=storeColumnNames" json:"store_column_names,omitempty"`
	// An ordered list of column IDs of which the index is comprised. This list
	// parallels the column_names list and does not include any additional stored
	// columns.
	ColumnIDs []ColumnID `protobuf:"varint,6,rep,name=column_ids,json=columnIds,casttype=ColumnID" json:"column_ids,omitempty"`
	// An ordered list of IDs for the additional columns associated with the
	// index:
	//  - implicit columns, which are all the primary key columns that are not
	//    already part of the index (i.e. PrimaryIndex.column_ids - column_ids).
	//  - stored columns (the columns in store_column_names) if this index uses the
	//    old STORING encoding (key-encoded data).
	//
	// Only used for secondary indexes.
	// For non-unique indexes, these columns are appended to the key.
	// For unique indexes, these columns are stored in the value (unless the key
	// contains a NULL value: then the extra columns are appended to the key to
	// unique-ify it).
	// This distinction exists because we want to be able to insert an entry using
	// a single conditional put on the key.
	ExtraColumnIDs []ColumnID `protobuf:"varint,7,rep,name=extra_column_ids,json=extraColumnIds,casttype=ColumnID" json:"extra_column_ids,omitempty"`
	// An ordered list of column IDs that parallels store_column_names if this
	// index uses the new STORING encoding (value-encoded data, always in the KV
	// value).
	StoreColumnIDs []ColumnID `protobuf:"varint,14,rep,name=store_column_ids,json=storeColumnIds,casttype=ColumnID" json:"store_column_ids,omitempty"`
	// CompositeColumnIDs contains an ordered list of IDs of columns that appear
	// in the index and have a composite encoding. Includes IDs from both
	// column_ids and extra_column_ids.
	CompositeColumnIDs []ColumnID `protobuf:"varint,13,rep,name=composite_column_ids,json=compositeColumnIds,casttype=ColumnID" json:"composite_column_ids,omitempty"`
	// ForeignKey and ReferencedBy are deprecated and not stored from 19.2 onward.
	ForeignKey   ForeignKeyReference   `protobuf:"bytes,9,opt,name=foreign_key,json=foreignKey" json:"foreign_key"`        // Deprecated: Do not use.
	ReferencedBy []ForeignKeyReference `protobuf:"bytes,10,rep,name=referenced_by,json=referencedBy" json:"referenced_by"` // Deprecated: Do not use.
	// Interleave, if it's not the zero value, describes how this index's data is
	// interleaved into another index's data.
	Interleave InterleaveDescriptor `protobuf:"bytes,11,opt,name=interleave" json:"interleave"`
	// InterleavedBy contains a reference to every table/index that is interleaved
	// into this one.
	//
	// Note that any of these indexes can themselves be interleaved by other
	// tables but this list contains only those for which this index is a direct
	// interleave parent.
	//
	// Only the Table and Index fields of the ForeignKeyReference are used. And
	// despite the message used here, interleavings don't have to have
	// corresponding foreign key references (and whether they do or not is
	// irrelevant for this field).
	InterleavedBy []ForeignKeyReference `protobuf:"bytes,12,rep,name=interleaved_by,json=interleavedBy" json:"interleaved_by"`
	// Partitioning, if it's not the zero value, describes how this index's data
	// is partitioned into spans of keys each addressable by zone configs.
	Partitioning PartitioningDescriptor `protobuf:"bytes,15,opt,name=partitioning" json:"partitioning"`
	// Type is the type of index, inverted or forward.
	Type IndexDescriptor_Type `protobuf:"varint,16,opt,name=type,enum=cockroach.sql.sqlbase.IndexDescriptor_Type" json:"type"`
	// CreatedExplicitly specifies whether this index was created explicitly
	// (i.e. via 'CREATE INDEX' statement).
	CreatedExplicitly bool `protobuf:"varint,17,opt,name=created_explicitly,json=createdExplicitly" json:"created_explicitly"`
	// EncodingType represents what sort of k/v encoding is used to store this descriptor on disk.
	// As of now, this includes the existing secondary index encoding, or the primary index encoding.
	// N.B. This field is only recognized on secondary indexes.
	EncodingType IndexDescriptorEncodingType `protobuf:"varint,19,opt,name=encoding_type,json=encodingType,casttype=IndexDescriptorEncodingType" json:"encoding_type"`
	// Sharded, if it's not the zero value, describes how this index is sharded.
	Sharded ShardedDescriptor `protobuf:"bytes,20,opt,name=sharded" json:"sharded"`
	// Disabled is used by the DROP PRIMARY KEY command to mark
	// that this index is disabled for further use.
	Disabled bool `protobuf:"varint,21,opt,name=disabled" json:"disabled"`
	// GeoConfig, if it's not the zero value, describes configuration for
	// this geospatial inverted index.
	GeoConfig geoindex.Config `protobuf:"bytes,22,opt,name=geo_config,json=geoConfig" json:"geo_config"`
	// Predicate, if it's not empty, indicates that the index is a partial index
	// with Predicate as the expression. If Predicate is empty, the index is not
	// a partial index. Columns are referred to in the expression by their name.
	// TODO(mgartner): Update the comment to explain that columns are referenced
	// by their ID once #49766 is addressed.
	Predicate string `protobuf:"bytes,23,opt,name=predicate" json:"predicate"`
}

func (m *IndexDescriptor) Reset()         { *m = IndexDescriptor{} }
func (m *IndexDescriptor) String() string { return proto.CompactTextString(m) }
func (*IndexDescriptor) ProtoMessage()    {}
func (*IndexDescriptor) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{7}
}
func (m *IndexDescriptor) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IndexDescriptor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *IndexDescriptor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IndexDescriptor.Merge(dst, src)
}
func (m *IndexDescriptor) XXX_Size() int {
	return m.Size()
}
func (m *IndexDescriptor) XXX_DiscardUnknown() {
	xxx_messageInfo_IndexDescriptor.DiscardUnknown(m)
}

var xxx_messageInfo_IndexDescriptor proto.InternalMessageInfo

// ConstraintToUpdate represents a constraint to be added to the table and
// validated for existing rows. More generally, in the future, when we support
// adding constraints that are unvalidated for existing rows and can be
// validated later using VALIDATE CONSTRAINT, this mutation will also represent
// either adding an unvalidated constraint or validating an existing constraint.
//
// This mutation effects changes only in the backfill step of the schema
// changer: First, a new version of the table descriptor with the constraint
// added is published, after all columns being added have been backfilled. After
// waiting for the constraint to be enforced for writes on all nodes, the
// constraint is then validated for all existing rows. This ensures that
// constraints added to columns that are being added are correctly enforced
// before the column becomes public.
type ConstraintToUpdate struct {
	ConstraintType ConstraintToUpdate_ConstraintType `protobuf:"varint,1,req,name=constraint_type,json=constraintType,enum=cockroach.sql.sqlbase.ConstraintToUpdate_ConstraintType" json:"constraint_type"`
	Name           string                            `protobuf:"bytes,2,req,name=name" json:"name"`
	Check          TableDescriptor_CheckConstraint   `protobuf:"bytes,3,opt,name=check" json:"check"`
	// All fields past 3 haven't been persisted before 19.2.
	ForeignKey    ForeignKeyConstraint `protobuf:"bytes,4,opt,name=foreign_key,json=foreignKey" json:"foreign_key"`
	NotNullColumn ColumnID             `protobuf:"varint,6,opt,name=not_null_column,json=notNullColumn,casttype=ColumnID" json:"not_null_column"`
}

func (m *ConstraintToUpdate) Reset()         { *m = ConstraintToUpdate{} }
func (m *ConstraintToUpdate) String() string { return proto.CompactTextString(m) }
func (*ConstraintToUpdate) ProtoMessage()    {}
func (*ConstraintToUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{8}
}
func (m *ConstraintToUpdate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ConstraintToUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *ConstraintToUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConstraintToUpdate.Merge(dst, src)
}
func (m *ConstraintToUpdate) XXX_Size() int {
	return m.Size()
}
func (m *ConstraintToUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_ConstraintToUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_ConstraintToUpdate proto.InternalMessageInfo

// PrimaryKeySwap is a mutation corresponding to the atomic swap phase
// during a primary key change where old versions of indexes are exchanged for
// updated versions, and the table's new primary key is written into the descriptor.
type PrimaryKeySwap struct {
	// old_primary_index_id is the ID of the old primary index for the table.
	OldPrimaryIndexId IndexID `protobuf:"varint,4,opt,name=old_primary_index_id,json=oldPrimaryIndexId,casttype=IndexID" json:"old_primary_index_id"`
	// new_primary_index_id is the ID of the new primary index for the table.
	NewPrimaryIndexId IndexID `protobuf:"varint,1,opt,name=new_primary_index_id,json=newPrimaryIndexId,casttype=IndexID" json:"new_primary_index_id"`
	// old_indexes and new_indexes are lists of IndexID's where the i'th index in old_indexes will be
	// swapped out with the i'th index in new_indexes.
	OldIndexes []IndexID `protobuf:"varint,2,rep,name=old_indexes,json=oldIndexes,casttype=IndexID" json:"old_indexes,omitempty"`
	NewIndexes []IndexID `protobuf:"varint,3,rep,name=new_indexes,json=newIndexes,casttype=IndexID" json:"new_indexes,omitempty"`
}

func (m *PrimaryKeySwap) Reset()         { *m = PrimaryKeySwap{} }
func (m *PrimaryKeySwap) String() string { return proto.CompactTextString(m) }
func (*PrimaryKeySwap) ProtoMessage()    {}
func (*PrimaryKeySwap) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{9}
}
func (m *PrimaryKeySwap) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PrimaryKeySwap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *PrimaryKeySwap) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PrimaryKeySwap.Merge(dst, src)
}
func (m *PrimaryKeySwap) XXX_Size() int {
	return m.Size()
}
func (m *PrimaryKeySwap) XXX_DiscardUnknown() {
	xxx_messageInfo_PrimaryKeySwap.DiscardUnknown(m)
}

var xxx_messageInfo_PrimaryKeySwap proto.InternalMessageInfo

// ComputedColumnSwap is a mutation corresponding to the atomic swap phase
// where Column a' that is computed using Column a is swapped to replace
// Column a while Column a becomes computed using a'.
type ComputedColumnSwap struct {
	NewColumnId ColumnID `protobuf:"varint,1,opt,name=new_column_id,json=newColumnId,casttype=ColumnID" json:"new_column_id"`
	OldColumnId ColumnID `protobuf:"varint,2,opt,name=old_column_id,json=oldColumnId,casttype=ColumnID" json:"old_column_id"`
}

func (m *ComputedColumnSwap) Reset()         { *m = ComputedColumnSwap{} }
func (m *ComputedColumnSwap) String() string { return proto.CompactTextString(m) }
func (*ComputedColumnSwap) ProtoMessage()    {}
func (*ComputedColumnSwap) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{10}
}
func (m *ComputedColumnSwap) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ComputedColumnSwap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *ComputedColumnSwap) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ComputedColumnSwap.Merge(dst, src)
}
func (m *ComputedColumnSwap) XXX_Size() int {
	return m.Size()
}
func (m *ComputedColumnSwap) XXX_DiscardUnknown() {
	xxx_messageInfo_ComputedColumnSwap.DiscardUnknown(m)
}

var xxx_messageInfo_ComputedColumnSwap proto.InternalMessageInfo

// A DescriptorMutation represents a column or an index that
// has either been added or dropped and hasn't yet transitioned
// into a stable state: completely backfilled and visible, or
// completely deleted. A table descriptor in the middle of a
// schema change will have a DescriptorMutation FIFO queue
// containing each column/index descriptor being added or dropped.
// Mutations for constraints work differently from columns and
// indexes; see the documentation for ConstraintToUpdate.
type DescriptorMutation struct {
	// Types that are valid to be assigned to Descriptor_:
	//	*DescriptorMutation_Column
	//	*DescriptorMutation_Index
	//	*DescriptorMutation_Constraint
	//	*DescriptorMutation_PrimaryKeySwap
	//	*DescriptorMutation_ComputedColumnSwap
	Descriptor_ isDescriptorMutation_Descriptor_ `protobuf_oneof:"descriptor"`
	State       DescriptorMutation_State         `protobuf:"varint,3,opt,name=state,enum=cockroach.sql.sqlbase.DescriptorMutation_State" json:"state"`
	Direction   DescriptorMutation_Direction     `protobuf:"varint,4,opt,name=direction,enum=cockroach.sql.sqlbase.DescriptorMutation_Direction" json:"direction"`
	// The mutation id used to group mutations that should be applied together.
	// This is used for situations like creating a unique column, which
	// involve adding two mutations: one for the column, and another for the
	// unique constraint index.
	MutationID MutationID `protobuf:"varint,5,opt,name=mutation_id,json=mutationId,casttype=MutationID" json:"mutation_id"`
	// Indicates that this mutation is a rollback.
	Rollback bool `protobuf:"varint,7,opt,name=rollback" json:"rollback"`
}

func (m *DescriptorMutation) Reset()         { *m = DescriptorMutation{} }
func (m *DescriptorMutation) String() string { return proto.CompactTextString(m) }
func (*DescriptorMutation) ProtoMessage()    {}
func (*DescriptorMutation) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{11}
}
func (m *DescriptorMutation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DescriptorMutation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *DescriptorMutation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DescriptorMutation.Merge(dst, src)
}
func (m *DescriptorMutation) XXX_Size() int {
	return m.Size()
}
func (m *DescriptorMutation) XXX_DiscardUnknown() {
	xxx_messageInfo_DescriptorMutation.DiscardUnknown(m)
}

var xxx_messageInfo_DescriptorMutation proto.InternalMessageInfo

type isDescriptorMutation_Descriptor_ interface {
	isDescriptorMutation_Descriptor_()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type DescriptorMutation_Column struct {
	Column *ColumnDescriptor `protobuf:"bytes,1,opt,name=column,oneof"`
}
type DescriptorMutation_Index struct {
	Index *IndexDescriptor `protobuf:"bytes,2,opt,name=index,oneof"`
}
type DescriptorMutation_Constraint struct {
	Constraint *ConstraintToUpdate `protobuf:"bytes,8,opt,name=constraint,oneof"`
}
type DescriptorMutation_PrimaryKeySwap struct {
	PrimaryKeySwap *PrimaryKeySwap `protobuf:"bytes,9,opt,name=primaryKeySwap,oneof"`
}
type DescriptorMutation_ComputedColumnSwap struct {
	ComputedColumnSwap *ComputedColumnSwap `protobuf:"bytes,10,opt,name=computedColumnSwap,oneof"`
}

func (*DescriptorMutation_Column) isDescriptorMutation_Descriptor_()             {}
func (*DescriptorMutation_Index) isDescriptorMutation_Descriptor_()              {}
func (*DescriptorMutation_Constraint) isDescriptorMutation_Descriptor_()         {}
func (*DescriptorMutation_PrimaryKeySwap) isDescriptorMutation_Descriptor_()     {}
func (*DescriptorMutation_ComputedColumnSwap) isDescriptorMutation_Descriptor_() {}

func (m *DescriptorMutation) GetDescriptor_() isDescriptorMutation_Descriptor_ {
	if m != nil {
		return m.Descriptor_
	}
	return nil
}

func (m *DescriptorMutation) GetColumn() *ColumnDescriptor {
	if x, ok := m.GetDescriptor_().(*DescriptorMutation_Column); ok {
		return x.Column
	}
	return nil
}

func (m *DescriptorMutation) GetIndex() *IndexDescriptor {
	if x, ok := m.GetDescriptor_().(*DescriptorMutation_Index); ok {
		return x.Index
	}
	return nil
}

func (m *DescriptorMutation) GetConstraint() *ConstraintToUpdate {
	if x, ok := m.GetDescriptor_().(*DescriptorMutation_Constraint); ok {
		return x.Constraint
	}
	return nil
}

func (m *DescriptorMutation) GetPrimaryKeySwap() *PrimaryKeySwap {
	if x, ok := m.GetDescriptor_().(*DescriptorMutation_PrimaryKeySwap); ok {
		return x.PrimaryKeySwap
	}
	return nil
}

func (m *DescriptorMutation) GetComputedColumnSwap() *ComputedColumnSwap {
	if x, ok := m.GetDescriptor_().(*DescriptorMutation_ComputedColumnSwap); ok {
		return x.ComputedColumnSwap
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*DescriptorMutation) 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 _DescriptorMutation_OneofMarshaler, _DescriptorMutation_OneofUnmarshaler, _DescriptorMutation_OneofSizer, []interface{}{
		(*DescriptorMutation_Column)(nil),
		(*DescriptorMutation_Index)(nil),
		(*DescriptorMutation_Constraint)(nil),
		(*DescriptorMutation_PrimaryKeySwap)(nil),
		(*DescriptorMutation_ComputedColumnSwap)(nil),
	}
}

func _DescriptorMutation_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*DescriptorMutation)
	// descriptor
	switch x := m.Descriptor_.(type) {
	case *DescriptorMutation_Column:
		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Column); err != nil {
			return err
		}
	case *DescriptorMutation_Index:
		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Index); err != nil {
			return err
		}
	case *DescriptorMutation_Constraint:
		_ = b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Constraint); err != nil {
			return err
		}
	case *DescriptorMutation_PrimaryKeySwap:
		_ = b.EncodeVarint(9<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.PrimaryKeySwap); err != nil {
			return err
		}
	case *DescriptorMutation_ComputedColumnSwap:
		_ = b.EncodeVarint(10<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ComputedColumnSwap); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("DescriptorMutation.Descriptor_ has unexpected type %T", x)
	}
	return nil
}

func _DescriptorMutation_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*DescriptorMutation)
	switch tag {
	case 1: // descriptor.column
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ColumnDescriptor)
		err := b.DecodeMessage(msg)
		m.Descriptor_ = &DescriptorMutation_Column{msg}
		return true, err
	case 2: // descriptor.index
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(IndexDescriptor)
		err := b.DecodeMessage(msg)
		m.Descriptor_ = &DescriptorMutation_Index{msg}
		return true, err
	case 8: // descriptor.constraint
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ConstraintToUpdate)
		err := b.DecodeMessage(msg)
		m.Descriptor_ = &DescriptorMutation_Constraint{msg}
		return true, err
	case 9: // descriptor.primaryKeySwap
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(PrimaryKeySwap)
		err := b.DecodeMessage(msg)
		m.Descriptor_ = &DescriptorMutation_PrimaryKeySwap{msg}
		return true, err
	case 10: // descriptor.computedColumnSwap
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ComputedColumnSwap)
		err := b.DecodeMessage(msg)
		m.Descriptor_ = &DescriptorMutation_ComputedColumnSwap{msg}
		return true, err
	default:
		return false, nil
	}
}

func _DescriptorMutation_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*DescriptorMutation)
	// descriptor
	switch x := m.Descriptor_.(type) {
	case *DescriptorMutation_Column:
		s := proto.Size(x.Column)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *DescriptorMutation_Index:
		s := proto.Size(x.Index)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *DescriptorMutation_Constraint:
		s := proto.Size(x.Constraint)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *DescriptorMutation_PrimaryKeySwap:
		s := proto.Size(x.PrimaryKeySwap)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *DescriptorMutation_ComputedColumnSwap:
		s := proto.Size(x.ComputedColumnSwap)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// A TableDescriptor represents a table or view and is stored in a
// structured metadata key. The TableDescriptor has a globally-unique ID,
// while its member {Column,Index}Descriptors have locally-unique IDs.
type TableDescriptor struct {
	// The table name. It should be normalized using NormalizeName() before
	// comparing it.
	Name string `protobuf:"bytes,1,opt,name=name" json:"name"`
	ID   ID     `protobuf:"varint,3,opt,name=id,casttype=ID" json:"id"`
	// ID of the parent database.
	ParentID ID `protobuf:"varint,4,opt,name=parent_id,json=parentId,casttype=ID" json:"parent_id"`
	// ID of the parent schema. For backwards compatibility, 0 means the table is
	// scoped under the public physical schema (id 29). Because of this backward
	// compatibility issue, this field should not be accessed directly or through
	// the generated getter. Instead, use GetParentSchemaID() which is defined in
	// structured.go.
	UnexposedParentSchemaID ID `protobuf:"varint,40,opt,name=unexposed_parent_schema_id,json=unexposedParentSchemaId,casttype=ID" json:"unexposed_parent_schema_id"`
	// Monotonically increasing version of the table descriptor.
	//
	// The design maintains two invariants:
	// 1. Two safe versions: A transaction at a particular timestamp is
	//    allowed to use one of two versions of a table descriptor:
	//    the one that would be read from the store at that timestamp,
	//    and the one behind it in version.
	// 2. Two leased versions: There can be valid leases on at most the 2
	//    latest versions of a table in the cluster at any time. New leases
	//    are only granted on the latest version.
	//
	// The database must maintain correctness in light of there being two
	// versions of a descriptor that can be used.
	//
	// Multiple schema change mutations can be grouped together on a
	// particular version increment.
	Version DescriptorVersion `protobuf:"varint,5,opt,name=version,casttype=DescriptorVersion" json:"version"`
	// Last modification time of the table descriptor.
	// Starting in 19.2 this field's value may sometime be zero-valued in which
	// case the MVCC timestamp of the row containing the value should be used to
	// populate it. This dance allows us to avoid observing the commit timestamp
	// for transactions which increment the descriptor version.
	// Encoded TableDescriptor structs should not be stored directly but rather
	// should live inside of a Descriptor. The Descriptor.Table() method takes an
	// hlc timestamp to ensure that this field is set properly when extracted from
	// a Descriptor.
	ModificationTime hlc.Timestamp      `protobuf:"bytes,7,opt,name=modification_time,json=modificationTime" json:"modification_time"`
	Columns          []ColumnDescriptor `protobuf:"bytes,8,rep,name=columns" json:"columns"`
	// next_column_id is used to ensure that deleted column ids are not reused.
	NextColumnID ColumnID `protobuf:"varint,9,opt,name=next_column_id,json=nextColumnId,casttype=ColumnID" json:"next_column_id"`
	// families holds information about the column families of this table.
	// This list has at least length 1, in which case all columns are stored in the same family.
	// families is stored in sorted order by family ID.
	Families []ColumnFamilyDescriptor `protobuf:"bytes,22,rep,name=families" json:"families"`
	// next_family_id is used to ensure that deleted family ids are not reused.
	NextFamilyID FamilyID        `protobuf:"varint,23,opt,name=next_family_id,json=nextFamilyId,casttype=FamilyID" json:"next_family_id"`
	PrimaryIndex IndexDescriptor `protobuf:"bytes,10,opt,name=primary_index,json=primaryIndex" json:"primary_index"`
	// indexes are all the secondary indexes.
	Indexes []IndexDescriptor `protobuf:"bytes,11,rep,name=indexes" json:"indexes"`
	// next_index_id is used to ensure that deleted index ids are not reused.
	NextIndexID IndexID              `protobuf:"varint,12,opt,name=next_index_id,json=nextIndexId,casttype=IndexID" json:"next_index_id"`
	Privileges  *PrivilegeDescriptor `protobuf:"bytes,13,opt,name=privileges" json:"privileges,omitempty"`
	// Columns or indexes being added or deleted in a FIFO order.
	Mutations []DescriptorMutation               `protobuf:"bytes,14,rep,name=mutations" json:"mutations"`
	Lease     *TableDescriptor_SchemaChangeLease `protobuf:"bytes,15,opt,name=lease" json:"lease,omitempty"` // Deprecated: Do not use.
	// An id for the next group of mutations to be applied together.
	NextMutationID MutationID `protobuf:"varint,16,opt,name=next_mutation_id,json=nextMutationId,casttype=MutationID" json:"next_mutation_id"`
	// format_version declares which sql to key:value mapping is being used to
	// represent the data in this table.
	FormatVersion FormatVersion                      `protobuf:"varint,17,opt,name=format_version,json=formatVersion,casttype=FormatVersion" json:"format_version"`
	State         TableDescriptor_State              `protobuf:"varint,19,opt,name=state,enum=cockroach.sql.sqlbase.TableDescriptor_State" json:"state"`
	OfflineReason string                             `protobuf:"bytes,38,opt,name=offline_reason,json=offlineReason" json:"offline_reason"`
	Checks        []*TableDescriptor_CheckConstraint `protobuf:"bytes,20,rep,name=checks" json:"checks,omitempty"`
	// A list of draining names. The draining name entries are drained from
	// the cluster wide name caches by incrementing the version for this
	// descriptor and ensuring that there are no leases on prior
	// versions of the descriptor. This field is then cleared and the version
	// of the descriptor incremented.
	DrainingNames []TableDescriptor_NameInfo `protobuf:"bytes,21,rep,name=draining_names,json=drainingNames" json:"draining_names"`
	// The TableDescriptor is used for views in addition to tables. Views
	// use mostly the same fields as tables, but need to track the actual
	// query from the view definition as well.
	//
	// For now we only track a string representation of the query. This prevents
	// us from easily supporting things like renames of the dependencies of a
	// view. Eventually we'll want to switch to a semantic encoding of the query
	// that relies on IDs rather than names so that we can support renames of
	// fields relied on by the query, as Postgres does.
	//
	// Note: The presence of this field is used to determine whether or not
	// a TableDescriptor represents a view.
	ViewQuery string `protobuf:"bytes,24,opt,name=view_query,json=viewQuery" json:"view_query"`
	// The IDs of all relations that this depends on.
	// Only ever populated if this descriptor is for a view.
	DependsOn []ID `protobuf:"varint,25,rep,name=dependsOn,casttype=ID" json:"dependsOn,omitempty"`
	// All references to this table/view from other views and sequences in the system,
	// tracked down to the column/index so that we can restrict changes to them while
	// they're still being referred to.
	DependedOnBy []TableDescriptor_Reference `protobuf:"bytes,26,rep,name=dependedOnBy" json:"dependedOnBy"`
	// Mutation jobs queued for execution in a FIFO order. Remains synchronized
	// with the mutations list.
	MutationJobs []TableDescriptor_MutationJob `protobuf:"bytes,27,rep,name=mutationJobs" json:"mutationJobs"`
	// The presence of sequence_opts indicates that this descriptor is for a sequence.
	SequenceOpts *TableDescriptor_SequenceOpts `protobuf:"bytes,28,opt,name=sequence_opts,json=sequenceOpts" json:"sequence_opts,omitempty"`
	// The drop time is set when a table is truncated or dropped,
	// based on the current time in nanoseconds since the epoch.
	// Use this timestamp + GC TTL to start deleting the table's
	// contents.
	//
	// TODO(vivek): Replace with the ModificationTime. This has been
	// added only for migration purposes.
	DropTime int64 `protobuf:"varint,29,opt,name=drop_time,json=dropTime" json:"drop_time"`
	// ReplacementOf tracks prior IDs by which this table went -- e.g. when
	// TRUNCATE creates a replacement of a table and swaps it in for the the old
	// one, it should note on the new table the ID of the table it replaced. This
	// can be used when trying to track a table's history across truncatations.
	ReplacementOf TableDescriptor_Replacement `protobuf:"bytes,30,opt,name=replacement_of,json=replacementOf" json:"replacement_of"`
	AuditMode     TableDescriptor_AuditMode   `protobuf:"varint,31,opt,name=audit_mode,json=auditMode,enum=cockroach.sql.sqlbase.TableDescriptor_AuditMode" json:"audit_mode"`
	// The job id for a drop job is the id in the system.jobs table of the
	// dropping of this table.
	DropJobID int64 `protobuf:"varint,32,opt,name=drop_job_id,json=dropJobId" json:"drop_job_id"`
	// The schema elements that have been dropped and whose underlying
	// data needs to be gc-ed. These schema elements have already transitioned
	// through the drop state machine when they were in the above mutations
	// list, and can be safely deleted. The names for these schema elements
	// can be reused. This list is separate because mutations can
	// lie in this list for a long time (gc deadline) and should not block
	// the execution of other schema changes on the table.
	//
	// TODO(vivekmenezes): This is currently only used by the non-interleaved drop
	// index case. Also use for dropped interleaved indexes and columns.
	GCMutations []TableDescriptor_GCDescriptorMutation `protobuf:"bytes,33,rep,name=gc_mutations,json=gcMutations" json:"gc_mutations"`
	CreateQuery string                                 `protobuf:"bytes,34,opt,name=create_query,json=createQuery" json:"create_query"`
	// Starting in 19.2 CreateAsOfTime is initialized to zero for the first
	// version of a table and is populated from the MVCC timestamp of the read
	// like ModificationTime. See Descriptor.Table().
	// CreateAsOfSystemTime is used for CREATE TABLE ... AS ... and was
	// added in 19.1.
	CreateAsOfTime hlc.Timestamp `protobuf:"bytes,35,opt,name=create_as_of_time,json=createAsOfTime" json:"create_as_of_time"`
	// outbound_fks contains all foreign key constraints that have this table as
	// the origin table.
	OutboundFKs []ForeignKeyConstraint `protobuf:"bytes,36,rep,name=outbound_fks,json=outboundFks" json:"outbound_fks"`
	// inbound_fks contains all foreign key constraints that have this table as
	// the referenced table.
	InboundFKs []ForeignKeyConstraint `protobuf:"bytes,37,rep,name=inbound_fks,json=inboundFks" json:"inbound_fks"`
	// Temporary table support will be added to CRDB starting from 20.1. The temporary
	// flag is set to true for all temporary tables. All table descriptors created
	// before 20.1 refer to persistent tables, so lack of the flag being set implies
	// the table is persistent.
	Temporary bool `protobuf:"varint,39,opt,name=temporary" json:"temporary"`
}

func (m *TableDescriptor) Reset()         { *m = TableDescriptor{} }
func (m *TableDescriptor) String() string { return proto.CompactTextString(m) }
func (*TableDescriptor) ProtoMessage()    {}
func (*TableDescriptor) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{12}
}
func (m *TableDescriptor) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TableDescriptor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *TableDescriptor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TableDescriptor.Merge(dst, src)
}
func (m *TableDescriptor) XXX_Size() int {
	return m.Size()
}
func (m *TableDescriptor) XXX_DiscardUnknown() {
	xxx_messageInfo_TableDescriptor.DiscardUnknown(m)
}

var xxx_messageInfo_TableDescriptor proto.InternalMessageInfo

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

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

func (m *TableDescriptor) GetParentID() ID {
	if m != nil {
		return m.ParentID
	}
	return 0
}

func (m *TableDescriptor) GetUnexposedParentSchemaID() ID {
	if m != nil {
		return m.UnexposedParentSchemaID
	}
	return 0
}

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

func (m *TableDescriptor) GetModificationTime() hlc.Timestamp {
	if m != nil {
		return m.ModificationTime
	}
	return hlc.Timestamp{}
}

func (m *TableDescriptor) GetColumns() []ColumnDescriptor {
	if m != nil {
		return m.Columns
	}
	return nil
}

func (m *TableDescriptor) GetNextColumnID() ColumnID {
	if m != nil {
		return m.NextColumnID
	}
	return 0
}

func (m *TableDescriptor) GetFamilies() []ColumnFamilyDescriptor {
	if m != nil {
		return m.Families
	}
	return nil
}

func (m *TableDescriptor) GetNextFamilyID() FamilyID {
	if m != nil {
		return m.NextFamilyID
	}
	return 0
}

func (m *TableDescriptor) GetPrimaryIndex() IndexDescriptor {
	if m != nil {
		return m.PrimaryIndex
	}
	return IndexDescriptor{}
}

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

func (m *TableDescriptor) GetNextIndexID() IndexID {
	if m != nil {
		return m.NextIndexID
	}
	return 0
}

func (m *TableDescriptor) GetPrivileges() *PrivilegeDescriptor {
	if m != nil {
		return m.Privileges
	}
	return nil
}

func (m *TableDescriptor) GetMutations() []DescriptorMutation {
	if m != nil {
		return m.Mutations
	}
	return nil
}

// Deprecated: Do not use.
func (m *TableDescriptor) GetLease() *TableDescriptor_SchemaChangeLease {
	if m != nil {
		return m.Lease
	}
	return nil
}

func (m *TableDescriptor) GetNextMutationID() MutationID {
	if m != nil {
		return m.NextMutationID
	}
	return 0
}

func (m *TableDescriptor) GetFormatVersion() FormatVersion {
	if m != nil {
		return m.FormatVersion
	}
	return 0
}

func (m *TableDescriptor) GetState() TableDescriptor_State {
	if m != nil {
		return m.State
	}
	return TableDescriptor_PUBLIC
}

func (m *TableDescriptor) GetOfflineReason() string {
	if m != nil {
		return m.OfflineReason
	}
	return ""
}

func (m *TableDescriptor) GetChecks() []*TableDescriptor_CheckConstraint {
	if m != nil {
		return m.Checks
	}
	return nil
}

func (m *TableDescriptor) GetDrainingNames() []TableDescriptor_NameInfo {
	if m != nil {
		return m.DrainingNames
	}
	return nil
}

func (m *TableDescriptor) GetViewQuery() string {
	if m != nil {
		return m.ViewQuery
	}
	return ""
}

func (m *TableDescriptor) GetDependsOn() []ID {
	if m != nil {
		return m.DependsOn
	}
	return nil
}

func (m *TableDescriptor) GetDependedOnBy() []TableDescriptor_Reference {
	if m != nil {
		return m.DependedOnBy
	}
	return nil
}

func (m *TableDescriptor) GetMutationJobs() []TableDescriptor_MutationJob {
	if m != nil {
		return m.MutationJobs
	}
	return nil
}

func (m *TableDescriptor) GetSequenceOpts() *TableDescriptor_SequenceOpts {
	if m != nil {
		return m.SequenceOpts
	}
	return nil
}

func (m *TableDescriptor) GetDropTime() int64 {
	if m != nil {
		return m.DropTime
	}
	return 0
}

func (m *TableDescriptor) GetReplacementOf() TableDescriptor_Replacement {
	if m != nil {
		return m.ReplacementOf
	}
	return TableDescriptor_Replacement{}
}

func (m *TableDescriptor) GetAuditMode() TableDescriptor_AuditMode {
	if m != nil {
		return m.AuditMode
	}
	return TableDescriptor_DISABLED
}

func (m *TableDescriptor) GetDropJobID() int64 {
	if m != nil {
		return m.DropJobID
	}
	return 0
}

func (m *TableDescriptor) GetGCMutations() []TableDescriptor_GCDescriptorMutation {
	if m != nil {
		return m.GCMutations
	}
	return nil
}

func (m *TableDescriptor) GetCreateQuery() string {
	if m != nil {
		return m.CreateQuery
	}
	return ""
}

func (m *TableDescriptor) GetCreateAsOfTime() hlc.Timestamp {
	if m != nil {
		return m.CreateAsOfTime
	}
	return hlc.Timestamp{}
}

func (m *TableDescriptor) GetOutboundFKs() []ForeignKeyConstraint {
	if m != nil {
		return m.OutboundFKs
	}
	return nil
}

func (m *TableDescriptor) GetInboundFKs() []ForeignKeyConstraint {
	if m != nil {
		return m.InboundFKs
	}
	return nil
}

func (m *TableDescriptor) GetTemporary() bool {
	if m != nil {
		return m.Temporary
	}
	return false
}

// The schema update lease. A single goroutine across a cockroach cluster
// can own it, and will execute pending schema changes for this table.
// Since the execution of a pending schema change is through transactions,
// it is legal for more than one goroutine to attempt to execute it. This
// lease reduces write contention on the schema change.
type TableDescriptor_SchemaChangeLease struct {
	NodeID github_com_cockroachdb_cockroach_pkg_roachpb.NodeID `protobuf:"varint,1,opt,name=node_id,json=nodeId,casttype=github.com/cockroachdb/cockroach/pkg/roachpb.NodeID" json:"node_id"`
	// Nanoseconds since the Unix epoch.
	ExpirationTime int64 `protobuf:"varint,2,opt,name=expiration_time,json=expirationTime" json:"expiration_time"`
}

func (m *TableDescriptor_SchemaChangeLease) Reset()         { *m = TableDescriptor_SchemaChangeLease{} }
func (m *TableDescriptor_SchemaChangeLease) String() string { return proto.CompactTextString(m) }
func (*TableDescriptor_SchemaChangeLease) ProtoMessage()    {}
func (*TableDescriptor_SchemaChangeLease) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{12, 0}
}
func (m *TableDescriptor_SchemaChangeLease) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TableDescriptor_SchemaChangeLease) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *TableDescriptor_SchemaChangeLease) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TableDescriptor_SchemaChangeLease.Merge(dst, src)
}
func (m *TableDescriptor_SchemaChangeLease) XXX_Size() int {
	return m.Size()
}
func (m *TableDescriptor_SchemaChangeLease) XXX_DiscardUnknown() {
	xxx_messageInfo_TableDescriptor_SchemaChangeLease.DiscardUnknown(m)
}

var xxx_messageInfo_TableDescriptor_SchemaChangeLease proto.InternalMessageInfo

type TableDescriptor_CheckConstraint struct {
	// Expr is the expression that this check constraint represents.
	// Note that it is not correct to use Expr as output to display
	// to a user. User defined types within Expr have been serialized
	// in a internal format. Instead, format the result of
	// DeserializeTableDescExpr.
	Expr     string             `protobuf:"bytes,1,opt,name=expr" json:"expr"`
	Name     string             `protobuf:"bytes,2,opt,name=name" json:"name"`
	Validity ConstraintValidity `protobuf:"varint,3,opt,name=validity,enum=cockroach.sql.sqlbase.ConstraintValidity" json:"validity"`
	// An ordered list of column IDs used by the check constraint.
	ColumnIDs           []ColumnID `protobuf:"varint,5,rep,name=column_ids,json=columnIds,casttype=ColumnID" json:"column_ids,omitempty"`
	IsNonNullConstraint bool       `protobuf:"varint,6,opt,name=is_non_null_constraint,json=isNonNullConstraint" json:"is_non_null_constraint"`
	// Whether the check constraint should show up in the result of a `SHOW CREATE
	// TABLE..` statement.
	Hidden bool `protobuf:"varint,7,opt,name=hidden" json:"hidden"`
}

func (m *TableDescriptor_CheckConstraint) Reset()         { *m = TableDescriptor_CheckConstraint{} }
func (m *TableDescriptor_CheckConstraint) String() string { return proto.CompactTextString(m) }
func (*TableDescriptor_CheckConstraint) ProtoMessage()    {}
func (*TableDescriptor_CheckConstraint) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{12, 1}
}
func (m *TableDescriptor_CheckConstraint) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TableDescriptor_CheckConstraint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *TableDescriptor_CheckConstraint) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TableDescriptor_CheckConstraint.Merge(dst, src)
}
func (m *TableDescriptor_CheckConstraint) XXX_Size() int {
	return m.Size()
}
func (m *TableDescriptor_CheckConstraint) XXX_DiscardUnknown() {
	xxx_messageInfo_TableDescriptor_CheckConstraint.DiscardUnknown(m)
}

var xxx_messageInfo_TableDescriptor_CheckConstraint proto.InternalMessageInfo

// A table descriptor is named through a name map stored in the
// system.namespace table: a map from {parent_id, table_name} -> id.
// This name map can be cached for performance on a node in the cluster
// making reassigning a name complicated. In particular, since a
// name cannot be withdrawn across a cluster in a transaction at
// timestamp T, we have to worry about the following:
//
// 1. A table is dropped at T, and the name and descriptor are still
// cached and used by transactions at timestamps >= T.
// 2. A table is renamed from foo to bar at T, and both names foo and bar
// can be used by transactions at timestamps >= T.
// 3. A name foo is reassigned from one table to another at T, and the name
// foo can reference two different tables at timestamps >= T.
//
// The system ensures that a name can be resolved only to a single
// descriptor at a timestamp thereby permitting 1 and 2, but not 3
// (the name references two tables).
//
// The transaction at T is followed by a time period when names no longer
// a part of the namespace are drained from the system. Once the old name
// is drained from the system another transaction at timestamp S is
// executed to release the name for future use. The interval from T to S
// is called the name drain interval: If the T transaction is removing
// the name foo then, at timestamps above S, foo can no longer be resolved.
//
// Consider a transaction at T in which name B is dropped, a new name C is
// created. Name C is viable as soon as the transaction commits.
// When the transaction at S commits, the name B is released for reuse.
//
// The transaction at S runs through the schema changer, with the system
// returning a response to the client initiating transaction T only after
// transaction at S is committed. So effectively the SQL transaction once
// it returns can be followed by SQL transactions that do not observe
// old name mappings.
//
// Note: an exception to this is #19925 which needs to be fixed.
//
// In order for transaction at S to act properly the system.namespace
// table entry for an old name references the descriptor who was the
// prior owner of the name requiring draining.
//
// Before T:   B -> Desc B
//
// After T and before S: B -> Desc B, C -> Desc C
//
// After S: C -> Desc C
//
// Between T and S the name B is drained and the system is unable
// to assign it to another descriptor.
//
// BEGIN;
// RENAME foo TO bar;
// CREATE foo;
//
// will fail because CREATE foo is executed at T.
//
// RENAME foo TO bar;
// CREATE foo;
//
// will succeed because the RENAME returns after S and CREATE foo is
// executed after S.
//
// The above scheme suffers from the problem that a transaction can observe
// the partial effect of a committed transaction during the drain interval.
// For instance during the drain interval a transaction can see the correct
// assignment for C, and the old assignments for B.
//
type TableDescriptor_NameInfo struct {
	// The database that the table belonged to before the rename (tables can be
	// renamed from one db to another).
	ParentID ID `protobuf:"varint,1,opt,name=parent_id,json=parentId,casttype=ID" json:"parent_id"`
	// The schemaID of the schema the table belongs to before the rename/drop.
	// Required to correctly identify which namespace entry to reclaim.
	ParentSchemaID ID     `protobuf:"varint,3,opt,name=parent_schema_id,json=parentSchemaId,casttype=ID" json:"parent_schema_id"`
	Name           string `protobuf:"bytes,2,opt,name=name" json:"name"`
}

func (m *TableDescriptor_NameInfo) Reset()         { *m = TableDescriptor_NameInfo{} }
func (m *TableDescriptor_NameInfo) String() string { return proto.CompactTextString(m) }
func (*TableDescriptor_NameInfo) ProtoMessage()    {}
func (*TableDescriptor_NameInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{12, 2}
}
func (m *TableDescriptor_NameInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TableDescriptor_NameInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *TableDescriptor_NameInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TableDescriptor_NameInfo.Merge(dst, src)
}
func (m *TableDescriptor_NameInfo) XXX_Size() int {
	return m.Size()
}
func (m *TableDescriptor_NameInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_TableDescriptor_NameInfo.DiscardUnknown(m)
}

var xxx_messageInfo_TableDescriptor_NameInfo proto.InternalMessageInfo

type TableDescriptor_Reference struct {
	// The ID of the relation that depends on this one.
	ID ID `protobuf:"varint,1,opt,name=id,casttype=ID" json:"id"`
	// If applicable, the ID of this table's index that is referenced by the
	// dependent relation.
	IndexID IndexID `protobuf:"varint,2,opt,name=index_id,json=indexId,casttype=IndexID" json:"index_id"`
	// The IDs of this table's columns that are referenced by the dependent
	// relation.
	ColumnIDs []ColumnID `protobuf:"varint,3,rep,name=column_ids,json=columnIds,casttype=ColumnID" json:"column_ids,omitempty"`
}

func (m *TableDescriptor_Reference) Reset()         { *m = TableDescriptor_Reference{} }
func (m *TableDescriptor_Reference) String() string { return proto.CompactTextString(m) }
func (*TableDescriptor_Reference) ProtoMessage()    {}
func (*TableDescriptor_Reference) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{12, 3}
}
func (m *TableDescriptor_Reference) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TableDescriptor_Reference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *TableDescriptor_Reference) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TableDescriptor_Reference.Merge(dst, src)
}
func (m *TableDescriptor_Reference) XXX_Size() int {
	return m.Size()
}
func (m *TableDescriptor_Reference) XXX_DiscardUnknown() {
	xxx_messageInfo_TableDescriptor_Reference.DiscardUnknown(m)
}

var xxx_messageInfo_TableDescriptor_Reference proto.InternalMessageInfo

type TableDescriptor_MutationJob struct {
	// The mutation id of this mutation job.
	MutationID MutationID `protobuf:"varint,1,opt,name=mutation_id,json=mutationId,casttype=MutationID" json:"mutation_id"`
	// The job id for a mutation job is the id in the system.jobs table of the
	// schema change job executing the mutation referenced by mutation_id.
	JobID int64 `protobuf:"varint,2,opt,name=job_id,json=jobId" json:"job_id"`
}

func (m *TableDescriptor_MutationJob) Reset()         { *m = TableDescriptor_MutationJob{} }
func (m *TableDescriptor_MutationJob) String() string { return proto.CompactTextString(m) }
func (*TableDescriptor_MutationJob) ProtoMessage()    {}
func (*TableDescriptor_MutationJob) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{12, 4}
}
func (m *TableDescriptor_MutationJob) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TableDescriptor_MutationJob) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *TableDescriptor_MutationJob) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TableDescriptor_MutationJob.Merge(dst, src)
}
func (m *TableDescriptor_MutationJob) XXX_Size() int {
	return m.Size()
}
func (m *TableDescriptor_MutationJob) XXX_DiscardUnknown() {
	xxx_messageInfo_TableDescriptor_MutationJob.DiscardUnknown(m)
}

var xxx_messageInfo_TableDescriptor_MutationJob proto.InternalMessageInfo

type TableDescriptor_SequenceOpts struct {
	// How much to increment the sequence by when nextval() is called.
	Increment int64 `protobuf:"varint,1,opt,name=increment" json:"increment"`
	// Minimum value of the sequence.
	MinValue int64 `protobuf:"varint,2,opt,name=min_value,json=minValue" json:"min_value"`
	// Maximum value of the sequence.
	MaxValue int64 `protobuf:"varint,3,opt,name=max_value,json=maxValue" json:"max_value"`
	// Start value of the sequence.
	Start int64 `protobuf:"varint,4,opt,name=start" json:"start"`
	// Whether the sequence is virtual.
	Virtual       bool                                       `protobuf:"varint,5,opt,name=virtual" json:"virtual"`
	SequenceOwner TableDescriptor_SequenceOpts_SequenceOwner `protobuf:"bytes,6,opt,name=sequence_owner,json=sequenceOwner" json:"sequence_owner"`
}

func (m *TableDescriptor_SequenceOpts) Reset()         { *m = TableDescriptor_SequenceOpts{} }
func (m *TableDescriptor_SequenceOpts) String() string { return proto.CompactTextString(m) }
func (*TableDescriptor_SequenceOpts) ProtoMessage()    {}
func (*TableDescriptor_SequenceOpts) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{12, 5}
}
func (m *TableDescriptor_SequenceOpts) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TableDescriptor_SequenceOpts) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *TableDescriptor_SequenceOpts) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TableDescriptor_SequenceOpts.Merge(dst, src)
}
func (m *TableDescriptor_SequenceOpts) XXX_Size() int {
	return m.Size()
}
func (m *TableDescriptor_SequenceOpts) XXX_DiscardUnknown() {
	xxx_messageInfo_TableDescriptor_SequenceOpts.DiscardUnknown(m)
}

var xxx_messageInfo_TableDescriptor_SequenceOpts proto.InternalMessageInfo

type TableDescriptor_SequenceOpts_SequenceOwner struct {
	// Sequence Owner's Column ID
	OwnerColumnID ColumnID `protobuf:"varint,1,opt,name=owner_column_id,json=ownerColumnId,casttype=ColumnID" json:"owner_column_id"`
	// Sequence Owner's Table ID
	OwnerTableID ID `protobuf:"varint,2,opt,name=owner_table_id,json=ownerTableId,casttype=ID" json:"owner_table_id"`
}

func (m *TableDescriptor_SequenceOpts_SequenceOwner) Reset() {
	*m = TableDescriptor_SequenceOpts_SequenceOwner{}
}
func (m *TableDescriptor_SequenceOpts_SequenceOwner) String() string {
	return proto.CompactTextString(m)
}
func (*TableDescriptor_SequenceOpts_SequenceOwner) ProtoMessage() {}
func (*TableDescriptor_SequenceOpts_SequenceOwner) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{12, 5, 0}
}
func (m *TableDescriptor_SequenceOpts_SequenceOwner) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TableDescriptor_SequenceOpts_SequenceOwner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *TableDescriptor_SequenceOpts_SequenceOwner) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TableDescriptor_SequenceOpts_SequenceOwner.Merge(dst, src)
}
func (m *TableDescriptor_SequenceOpts_SequenceOwner) XXX_Size() int {
	return m.Size()
}
func (m *TableDescriptor_SequenceOpts_SequenceOwner) XXX_DiscardUnknown() {
	xxx_messageInfo_TableDescriptor_SequenceOpts_SequenceOwner.DiscardUnknown(m)
}

var xxx_messageInfo_TableDescriptor_SequenceOpts_SequenceOwner proto.InternalMessageInfo

type TableDescriptor_Replacement struct {
	ID ID `protobuf:"varint,1,opt,name=id,casttype=ID" json:"id"`
	// Time is just used for debugging purposes. It is not used in business
	// logic. It is an HLC rather than just wall time only for historical
	// reasons. Prior to 20.1 it was populated with the commit timestamp of the
	// transaction which created this replacement. In 20.1 and after it is
	// populated with the read timestamp at which the descriptor being
	// replaced was read.
	Time hlc.Timestamp `protobuf:"bytes,2,opt,name=time" json:"time"`
}

func (m *TableDescriptor_Replacement) Reset()         { *m = TableDescriptor_Replacement{} }
func (m *TableDescriptor_Replacement) String() string { return proto.CompactTextString(m) }
func (*TableDescriptor_Replacement) ProtoMessage()    {}
func (*TableDescriptor_Replacement) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{12, 6}
}
func (m *TableDescriptor_Replacement) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TableDescriptor_Replacement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *TableDescriptor_Replacement) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TableDescriptor_Replacement.Merge(dst, src)
}
func (m *TableDescriptor_Replacement) XXX_Size() int {
	return m.Size()
}
func (m *TableDescriptor_Replacement) XXX_DiscardUnknown() {
	xxx_messageInfo_TableDescriptor_Replacement.DiscardUnknown(m)
}

var xxx_messageInfo_TableDescriptor_Replacement proto.InternalMessageInfo

type TableDescriptor_GCDescriptorMutation struct {
	IndexID  IndexID `protobuf:"varint,1,opt,name=index_id,json=indexId,casttype=IndexID" json:"index_id"`
	DropTime int64   `protobuf:"varint,2,opt,name=drop_time,json=dropTime" json:"drop_time"` // Deprecated: Do not use.
	// The job id for a mutation job is the id in the system.jobs table of the
	// schema change job executing the mutation referenced by mutation_id.
	JobID int64 `protobuf:"varint,3,opt,name=job_id,json=jobId" json:"job_id"` // Deprecated: Do not use.
}

func (m *TableDescriptor_GCDescriptorMutation) Reset()         { *m = TableDescriptor_GCDescriptorMutation{} }
func (m *TableDescriptor_GCDescriptorMutation) String() string { return proto.CompactTextString(m) }
func (*TableDescriptor_GCDescriptorMutation) ProtoMessage()    {}
func (*TableDescriptor_GCDescriptorMutation) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{12, 7}
}
func (m *TableDescriptor_GCDescriptorMutation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TableDescriptor_GCDescriptorMutation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *TableDescriptor_GCDescriptorMutation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TableDescriptor_GCDescriptorMutation.Merge(dst, src)
}
func (m *TableDescriptor_GCDescriptorMutation) XXX_Size() int {
	return m.Size()
}
func (m *TableDescriptor_GCDescriptorMutation) XXX_DiscardUnknown() {
	xxx_messageInfo_TableDescriptor_GCDescriptorMutation.DiscardUnknown(m)
}

var xxx_messageInfo_TableDescriptor_GCDescriptorMutation proto.InternalMessageInfo

// DatabaseDescriptor represents a namespace (aka database) and is stored
// in a structured metadata key. The DatabaseDescriptor has a globally-unique ID
// shared with other Descriptors.
// Permissions are applied to all tables in the namespace.
type DatabaseDescriptor struct {
	Name       string               `protobuf:"bytes,1,opt,name=name" json:"name"`
	ID         ID                   `protobuf:"varint,2,opt,name=id,casttype=ID" json:"id"`
	Privileges *PrivilegeDescriptor `protobuf:"bytes,3,opt,name=privileges" json:"privileges,omitempty"`
}

func (m *DatabaseDescriptor) Reset()         { *m = DatabaseDescriptor{} }
func (m *DatabaseDescriptor) String() string { return proto.CompactTextString(m) }
func (*DatabaseDescriptor) ProtoMessage()    {}
func (*DatabaseDescriptor) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{13}
}
func (m *DatabaseDescriptor) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DatabaseDescriptor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *DatabaseDescriptor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DatabaseDescriptor.Merge(dst, src)
}
func (m *DatabaseDescriptor) XXX_Size() int {
	return m.Size()
}
func (m *DatabaseDescriptor) XXX_DiscardUnknown() {
	xxx_messageInfo_DatabaseDescriptor.DiscardUnknown(m)
}

var xxx_messageInfo_DatabaseDescriptor proto.InternalMessageInfo

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

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

func (m *DatabaseDescriptor) GetPrivileges() *PrivilegeDescriptor {
	if m != nil {
		return m.Privileges
	}
	return nil
}

// TypeDescriptor represents a user defined type and is stored in a structured
// metadata key. The TypeDescriptor has a globally-unique ID shared with other
// Descriptors.
type TypeDescriptor struct {
	// parent_id represents the ID of the database that this type resides in.
	ParentID ID `protobuf:"varint,1,opt,name=parent_id,json=parentId,casttype=ID" json:"parent_id"`
	// parent_schema_id represents the ID of the schema that this type resides in.
	ParentSchemaID ID `protobuf:"varint,2,opt,name=parent_schema_id,json=parentSchemaId,casttype=ID" json:"parent_schema_id"`
	// name is the current name of this user defined type.
	Name string `protobuf:"bytes,3,opt,name=name" json:"name"`
	// id is the globally unique ID for this type.
	ID ID `protobuf:"varint,4,opt,name=id,casttype=ID" json:"id"`
	// array_type_id is the globally unique ID for the implicitly created array
	// type for this type. It is only set when the type descriptor points to a
	// non-array type.
	ArrayTypeID ID                  `protobuf:"varint,8,opt,name=array_type_id,json=arrayTypeId,casttype=ID" json:"array_type_id"`
	Kind        TypeDescriptor_Kind `protobuf:"varint,5,opt,name=kind,enum=cockroach.sql.sqlbase.TypeDescriptor_Kind" json:"kind"`
	// enum_members is the set of values in an enum.
	EnumMembers []TypeDescriptor_EnumMember `protobuf:"bytes,6,rep,name=enum_members,json=enumMembers" json:"enum_members"`
	// alias is the types.T that this descriptor is an alias for.
	Alias *types.T `protobuf:"bytes,7,opt,name=alias" json:"alias,omitempty"`
}

func (m *TypeDescriptor) Reset()         { *m = TypeDescriptor{} }
func (m *TypeDescriptor) String() string { return proto.CompactTextString(m) }
func (*TypeDescriptor) ProtoMessage()    {}
func (*TypeDescriptor) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{14}
}
func (m *TypeDescriptor) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TypeDescriptor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *TypeDescriptor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TypeDescriptor.Merge(dst, src)
}
func (m *TypeDescriptor) XXX_Size() int {
	return m.Size()
}
func (m *TypeDescriptor) XXX_DiscardUnknown() {
	xxx_messageInfo_TypeDescriptor.DiscardUnknown(m)
}

var xxx_messageInfo_TypeDescriptor proto.InternalMessageInfo

func (m *TypeDescriptor) GetParentID() ID {
	if m != nil {
		return m.ParentID
	}
	return 0
}

func (m *TypeDescriptor) GetParentSchemaID() ID {
	if m != nil {
		return m.ParentSchemaID
	}
	return 0
}

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

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

func (m *TypeDescriptor) GetArrayTypeID() ID {
	if m != nil {
		return m.ArrayTypeID
	}
	return 0
}

func (m *TypeDescriptor) GetKind() TypeDescriptor_Kind {
	if m != nil {
		return m.Kind
	}
	return TypeDescriptor_ENUM
}

func (m *TypeDescriptor) GetEnumMembers() []TypeDescriptor_EnumMember {
	if m != nil {
		return m.EnumMembers
	}
	return nil
}

func (m *TypeDescriptor) GetAlias() *types.T {
	if m != nil {
		return m.Alias
	}
	return nil
}

// EnumMember represents a value in an enum.
type TypeDescriptor_EnumMember struct {
	PhysicalRepresentation []byte `protobuf:"bytes,1,opt,name=physical_representation,json=physicalRepresentation" json:"physical_representation,omitempty"`
	LogicalRepresentation  string `protobuf:"bytes,2,opt,name=logical_representation,json=logicalRepresentation" json:"logical_representation"`
}

func (m *TypeDescriptor_EnumMember) Reset()         { *m = TypeDescriptor_EnumMember{} }
func (m *TypeDescriptor_EnumMember) String() string { return proto.CompactTextString(m) }
func (*TypeDescriptor_EnumMember) ProtoMessage()    {}
func (*TypeDescriptor_EnumMember) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{14, 0}
}
func (m *TypeDescriptor_EnumMember) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TypeDescriptor_EnumMember) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *TypeDescriptor_EnumMember) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TypeDescriptor_EnumMember.Merge(dst, src)
}
func (m *TypeDescriptor_EnumMember) XXX_Size() int {
	return m.Size()
}
func (m *TypeDescriptor_EnumMember) XXX_DiscardUnknown() {
	xxx_messageInfo_TypeDescriptor_EnumMember.DiscardUnknown(m)
}

var xxx_messageInfo_TypeDescriptor_EnumMember proto.InternalMessageInfo

// SchemaDescriptor represents a physical schema and is stored in a structured
// metadata key.
type SchemaDescriptor struct {
	// parent_id refers to the database the schema is in.
	ParentID ID `protobuf:"varint,1,opt,name=parent_id,json=parentId,casttype=ID" json:"parent_id"`
	// name is the name of the schema.
	Name string `protobuf:"bytes,2,opt,name=name" json:"name"`
	// id is the schema ID, globally unique across all descriptors.
	ID ID `protobuf:"varint,3,opt,name=id,casttype=ID" json:"id"`
	// privileges contains the privileges for the schema.
	Privileges *PrivilegeDescriptor `protobuf:"bytes,4,opt,name=privileges" json:"privileges,omitempty"`
}

func (m *SchemaDescriptor) Reset()         { *m = SchemaDescriptor{} }
func (m *SchemaDescriptor) String() string { return proto.CompactTextString(m) }
func (*SchemaDescriptor) ProtoMessage()    {}
func (*SchemaDescriptor) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{15}
}
func (m *SchemaDescriptor) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SchemaDescriptor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *SchemaDescriptor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SchemaDescriptor.Merge(dst, src)
}
func (m *SchemaDescriptor) XXX_Size() int {
	return m.Size()
}
func (m *SchemaDescriptor) XXX_DiscardUnknown() {
	xxx_messageInfo_SchemaDescriptor.DiscardUnknown(m)
}

var xxx_messageInfo_SchemaDescriptor proto.InternalMessageInfo

func (m *SchemaDescriptor) GetParentID() ID {
	if m != nil {
		return m.ParentID
	}
	return 0
}

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

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

func (m *SchemaDescriptor) GetPrivileges() *PrivilegeDescriptor {
	if m != nil {
		return m.Privileges
	}
	return nil
}

// Descriptor is a union type for descriptors for tables, schemas, databases,
// and types.
type Descriptor struct {
	// Types that are valid to be assigned to Union:
	//	*Descriptor_Table
	//	*Descriptor_Database
	//	*Descriptor_Type
	//	*Descriptor_Schema
	Union isDescriptor_Union `protobuf_oneof:"union"`
}

func (m *Descriptor) Reset()         { *m = Descriptor{} }
func (m *Descriptor) String() string { return proto.CompactTextString(m) }
func (*Descriptor) ProtoMessage()    {}
func (*Descriptor) Descriptor() ([]byte, []int) {
	return fileDescriptor_structured_6e223c312147c376, []int{16}
}
func (m *Descriptor) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Descriptor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *Descriptor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Descriptor.Merge(dst, src)
}
func (m *Descriptor) XXX_Size() int {
	return m.Size()
}
func (m *Descriptor) XXX_DiscardUnknown() {
	xxx_messageInfo_Descriptor.DiscardUnknown(m)
}

var xxx_messageInfo_Descriptor proto.InternalMessageInfo

type isDescriptor_Union interface {
	isDescriptor_Union()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type Descriptor_Table struct {
	Table *TableDescriptor `protobuf:"bytes,1,opt,name=table,oneof"`
}
type Descriptor_Database struct {
	Database *DatabaseDescriptor `protobuf:"bytes,2,opt,name=database,oneof"`
}
type Descriptor_Type struct {
	Type *TypeDescriptor `protobuf:"bytes,3,opt,name=type,oneof"`
}
type Descriptor_Schema struct {
	Schema *SchemaDescriptor `protobuf:"bytes,4,opt,name=schema,oneof"`
}

func (*Descriptor_Table) isDescriptor_Union()    {}
func (*Descriptor_Database) isDescriptor_Union() {}
func (*Descriptor_Type) isDescriptor_Union()     {}
func (*Descriptor_Schema) isDescriptor_Union()   {}

func (m *Descriptor) GetUnion() isDescriptor_Union {
	if m != nil {
		return m.Union
	}
	return nil
}

func (m *Descriptor) GetTable() *TableDescriptor {
	if x, ok := m.GetUnion().(*Descriptor_Table); ok {
		return x.Table
	}
	return nil
}

func (m *Descriptor) GetDatabase() *DatabaseDescriptor {
	if x, ok := m.GetUnion().(*Descriptor_Database); ok {
		return x.Database
	}
	return nil
}

func (m *Descriptor) GetType() *TypeDescriptor {
	if x, ok := m.GetUnion().(*Descriptor_Type); ok {
		return x.Type
	}
	return nil
}

func (m *Descriptor) GetSchema() *SchemaDescriptor {
	if x, ok := m.GetUnion().(*Descriptor_Schema); ok {
		return x.Schema
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Descriptor) 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 _Descriptor_OneofMarshaler, _Descriptor_OneofUnmarshaler, _Descriptor_OneofSizer, []interface{}{
		(*Descriptor_Table)(nil),
		(*Descriptor_Database)(nil),
		(*Descriptor_Type)(nil),
		(*Descriptor_Schema)(nil),
	}
}

func _Descriptor_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Descriptor)
	// union
	switch x := m.Union.(type) {
	case *Descriptor_Table:
		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Table); err != nil {
			return err
		}
	case *Descriptor_Database:
		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Database); err != nil {
			return err
		}
	case *Descriptor_Type:
		_ = b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Type); err != nil {
			return err
		}
	case *Descriptor_Schema:
		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Schema); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Descriptor.Union has unexpected type %T", x)
	}
	return nil
}

func _Descriptor_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Descriptor)
	switch tag {
	case 1: // union.table
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(TableDescriptor)
		err := b.DecodeMessage(msg)
		m.Union = &Descriptor_Table{msg}
		return true, err
	case 2: // union.database
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(DatabaseDescriptor)
		err := b.DecodeMessage(msg)
		m.Union = &Descriptor_Database{msg}
		return true, err
	case 3: // union.type
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(TypeDescriptor)
		err := b.DecodeMessage(msg)
		m.Union = &Descriptor_Type{msg}
		return true, err
	case 4: // union.schema
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(SchemaDescriptor)
		err := b.DecodeMessage(msg)
		m.Union = &Descriptor_Schema{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Descriptor_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Descriptor)
	// union
	switch x := m.Union.(type) {
	case *Descriptor_Table:
		s := proto.Size(x.Table)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Descriptor_Database:
		s := proto.Size(x.Database)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Descriptor_Type:
		s := proto.Size(x.Type)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Descriptor_Schema:
		s := proto.Size(x.Schema)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

func init() {
	proto.RegisterType((*ForeignKeyReference)(nil), "cockroach.sql.sqlbase.ForeignKeyReference")
	proto.RegisterType((*ForeignKeyConstraint)(nil), "cockroach.sql.sqlbase.ForeignKeyConstraint")
	proto.RegisterType((*ColumnDescriptor)(nil), "cockroach.sql.sqlbase.ColumnDescriptor")
	proto.RegisterType((*ColumnFamilyDescriptor)(nil), "cockroach.sql.sqlbase.ColumnFamilyDescriptor")
	proto.RegisterType((*InterleaveDescriptor)(nil), "cockroach.sql.sqlbase.InterleaveDescriptor")
	proto.RegisterType((*InterleaveDescriptor_Ancestor)(nil), "cockroach.sql.sqlbase.InterleaveDescriptor.Ancestor")
	proto.RegisterType((*ShardedDescriptor)(nil), "cockroach.sql.sqlbase.ShardedDescriptor")
	proto.RegisterType((*PartitioningDescriptor)(nil), "cockroach.sql.sqlbase.PartitioningDescriptor")
	proto.RegisterType((*PartitioningDescriptor_List)(nil), "cockroach.sql.sqlbase.PartitioningDescriptor.List")
	proto.RegisterType((*PartitioningDescriptor_Range)(nil), "cockroach.sql.sqlbase.PartitioningDescriptor.Range")
	proto.RegisterType((*IndexDescriptor)(nil), "cockroach.sql.sqlbase.IndexDescriptor")
	proto.RegisterType((*ConstraintToUpdate)(nil), "cockroach.sql.sqlbase.ConstraintToUpdate")
	proto.RegisterType((*PrimaryKeySwap)(nil), "cockroach.sql.sqlbase.PrimaryKeySwap")
	proto.RegisterType((*ComputedColumnSwap)(nil), "cockroach.sql.sqlbase.ComputedColumnSwap")
	proto.RegisterType((*DescriptorMutation)(nil), "cockroach.sql.sqlbase.DescriptorMutation")
	proto.RegisterType((*TableDescriptor)(nil), "cockroach.sql.sqlbase.TableDescriptor")
	proto.RegisterType((*TableDescriptor_SchemaChangeLease)(nil), "cockroach.sql.sqlbase.TableDescriptor.SchemaChangeLease")
	proto.RegisterType((*TableDescriptor_CheckConstraint)(nil), "cockroach.sql.sqlbase.TableDescriptor.CheckConstraint")
	proto.RegisterType((*TableDescriptor_NameInfo)(nil), "cockroach.sql.sqlbase.TableDescriptor.NameInfo")
	proto.RegisterType((*TableDescriptor_Reference)(nil), "cockroach.sql.sqlbase.TableDescriptor.Reference")
	proto.RegisterType((*TableDescriptor_MutationJob)(nil), "cockroach.sql.sqlbase.TableDescriptor.MutationJob")
	proto.RegisterType((*TableDescriptor_SequenceOpts)(nil), "cockroach.sql.sqlbase.TableDescriptor.SequenceOpts")
	proto.RegisterType((*TableDescriptor_SequenceOpts_SequenceOwner)(nil), "cockroach.sql.sqlbase.TableDescriptor.SequenceOpts.SequenceOwner")
	proto.RegisterType((*TableDescriptor_Replacement)(nil), "cockroach.sql.sqlbase.TableDescriptor.Replacement")
	proto.RegisterType((*TableDescriptor_GCDescriptorMutation)(nil), "cockroach.sql.sqlbase.TableDescriptor.GCDescriptorMutation")
	proto.RegisterType((*DatabaseDescriptor)(nil), "cockroach.sql.sqlbase.DatabaseDescriptor")
	proto.RegisterType((*TypeDescriptor)(nil), "cockroach.sql.sqlbase.TypeDescriptor")
	proto.RegisterType((*TypeDescriptor_EnumMember)(nil), "cockroach.sql.sqlbase.TypeDescriptor.EnumMember")
	proto.RegisterType((*SchemaDescriptor)(nil), "cockroach.sql.sqlbase.SchemaDescriptor")
	proto.RegisterType((*Descriptor)(nil), "cockroach.sql.sqlbase.Descriptor")
	proto.RegisterEnum("cockroach.sql.sqlbase.ConstraintValidity", ConstraintValidity_name, ConstraintValidity_value)
	proto.RegisterEnum("cockroach.sql.sqlbase.ForeignKeyReference_Action", ForeignKeyReference_Action_name, ForeignKeyReference_Action_value)
	proto.RegisterEnum("cockroach.sql.sqlbase.ForeignKeyReference_Match", ForeignKeyReference_Match_name, ForeignKeyReference_Match_value)
	proto.RegisterEnum("cockroach.sql.sqlbase.IndexDescriptor_Direction", IndexDescriptor_Direction_name, IndexDescriptor_Direction_value)
	proto.RegisterEnum("cockroach.sql.sqlbase.IndexDescriptor_Type", IndexDescriptor_Type_name, IndexDescriptor_Type_value)
	proto.RegisterEnum("cockroach.sql.sqlbase.ConstraintToUpdate_ConstraintType", ConstraintToUpdate_ConstraintType_name, ConstraintToUpdate_ConstraintType_value)
	proto.RegisterEnum("cockroach.sql.sqlbase.DescriptorMutation_State", DescriptorMutation_State_name, DescriptorMutation_State_value)
	proto.RegisterEnum("cockroach.sql.sqlbase.DescriptorMutation_Direction", DescriptorMutation_Direction_name, DescriptorMutation_Direction_value)
	proto.RegisterEnum("cockroach.sql.sqlbase.TableDescriptor_State", TableDescriptor_State_name, TableDescriptor_State_value)
	proto.RegisterEnum("cockroach.sql.sqlbase.TableDescriptor_AuditMode", TableDescriptor_AuditMode_name, TableDescriptor_AuditMode_value)
	proto.RegisterEnum("cockroach.sql.sqlbase.TypeDescriptor_Kind", TypeDescriptor_Kind_name, TypeDescriptor_Kind_value)
}
func (this *ForeignKeyReference) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ForeignKeyReference)
	if !ok {
		that2, ok := that.(ForeignKeyReference)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Table != that1.Table {
		return false
	}
	if this.Index != that1.Index {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Validity != that1.Validity {
		return false
	}
	if this.SharedPrefixLen != that1.SharedPrefixLen {
		return false
	}
	if this.OnDelete != that1.OnDelete {
		return false
	}
	if this.OnUpdate != that1.OnUpdate {
		return false
	}
	if this.Match != that1.Match {
		return false
	}
	return true
}
func (this *ForeignKeyConstraint) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ForeignKeyConstraint)
	if !ok {
		that2, ok := that.(ForeignKeyConstraint)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.OriginTableID != that1.OriginTableID {
		return false
	}
	if len(this.OriginColumnIDs) != len(that1.OriginColumnIDs) {
		return false
	}
	for i := range this.OriginColumnIDs {
		if this.OriginColumnIDs[i] != that1.OriginColumnIDs[i] {
			return false
		}
	}
	if len(this.ReferencedColumnIDs) != len(that1.ReferencedColumnIDs) {
		return false
	}
	for i := range this.ReferencedColumnIDs {
		if this.ReferencedColumnIDs[i] != that1.ReferencedColumnIDs[i] {
			return false
		}
	}
	if this.ReferencedTableID != that1.ReferencedTableID {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Validity != that1.Validity {
		return false
	}
	if this.OnDelete != that1.OnDelete {
		return false
	}
	if this.OnUpdate != that1.OnUpdate {
		return false
	}
	if this.Match != that1.Match {
		return false
	}
	if this.LegacyOriginIndex != that1.LegacyOriginIndex {
		return false
	}
	if this.LegacyReferencedIndex != that1.LegacyReferencedIndex {
		return false
	}
	return true
}
func (this *ColumnDescriptor) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ColumnDescriptor)
	if !ok {
		that2, ok := that.(ColumnDescriptor)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if !this.Type.Equal(that1.Type) {
		return false
	}
	if this.Nullable != that1.Nullable {
		return false
	}
	if this.DefaultExpr != nil && that1.DefaultExpr != nil {
		if *this.DefaultExpr != *that1.DefaultExpr {
			return false
		}
	} else if this.DefaultExpr != nil {
		return false
	} else if that1.DefaultExpr != nil {
		return false
	}
	if this.Hidden != that1.Hidden {
		return false
	}
	if len(this.UsesSequenceIds) != len(that1.UsesSequenceIds) {
		return false
	}
	for i := range this.UsesSequenceIds {
		if this.UsesSequenceIds[i] != that1.UsesSequenceIds[i] {
			return false
		}
	}
	if len(this.OwnsSequenceIds) != len(that1.OwnsSequenceIds) {
		return false
	}
	for i := range this.OwnsSequenceIds {
		if this.OwnsSequenceIds[i] != that1.OwnsSequenceIds[i] {
			return false
		}
	}
	if this.ComputeExpr != nil && that1.ComputeExpr != nil {
		if *this.ComputeExpr != *that1.ComputeExpr {
			return false
		}
	} else if this.ComputeExpr != nil {
		return false
	} else if that1.ComputeExpr != nil {
		return false
	}
	if this.LogicalColumnID != that1.LogicalColumnID {
		return false
	}
	if this.AlterColumnTypeInProgress != that1.AlterColumnTypeInProgress {
		return false
	}
	return true
}
func (this *ColumnFamilyDescriptor) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ColumnFamilyDescriptor)
	if !ok {
		that2, ok := that.(ColumnFamilyDescriptor)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if len(this.ColumnNames) != len(that1.ColumnNames) {
		return false
	}
	for i := range this.ColumnNames {
		if this.ColumnNames[i] != that1.ColumnNames[i] {
			return false
		}
	}
	if len(this.ColumnIDs) != len(that1.ColumnIDs) {
		return false
	}
	for i := range this.ColumnIDs {
		if this.ColumnIDs[i] != that1.ColumnIDs[i] {
			return false
		}
	}
	if this.DefaultColumnID != that1.DefaultColumnID {
		return false
	}
	return true
}
func (this *InterleaveDescriptor) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*InterleaveDescriptor)
	if !ok {
		that2, ok := that.(InterleaveDescriptor)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Ancestors) != len(that1.Ancestors) {
		return false
	}
	for i := range this.Ancestors {
		if !this.Ancestors[i].Equal(&that1.Ancestors[i]) {
			return false
		}
	}
	return true
}
func (this *InterleaveDescriptor_Ancestor) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*InterleaveDescriptor_Ancestor)
	if !ok {
		that2, ok := that.(InterleaveDescriptor_Ancestor)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.TableID != that1.TableID {
		return false
	}
	if this.IndexID != that1.IndexID {
		return false
	}
	if this.SharedPrefixLen != that1.SharedPrefixLen {
		return false
	}
	return true
}
func (this *ShardedDescriptor) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ShardedDescriptor)
	if !ok {
		that2, ok := that.(ShardedDescriptor)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.IsSharded != that1.IsSharded {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.ShardBuckets != that1.ShardBuckets {
		return false
	}
	if len(this.ColumnNames) != len(that1.ColumnNames) {
		return false
	}
	for i := range this.ColumnNames {
		if this.ColumnNames[i] != that1.ColumnNames[i] {
			return false
		}
	}
	return true
}
func (this *PartitioningDescriptor) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PartitioningDescriptor)
	if !ok {
		that2, ok := that.(PartitioningDescriptor)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.NumColumns != that1.NumColumns {
		return false
	}
	if len(this.List) != len(that1.List) {
		return false
	}
	for i := range this.List {
		if !this.List[i].Equal(&that1.List[i]) {
			return false
		}
	}
	if len(this.Range) != len(that1.Range) {
		return false
	}
	for i := range this.Range {
		if !this.Range[i].Equal(&that1.Range[i]) {
			return false
		}
	}
	return true
}
func (this *PartitioningDescriptor_List) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PartitioningDescriptor_List)
	if !ok {
		that2, ok := that.(PartitioningDescriptor_List)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if len(this.Values) != len(that1.Values) {
		return false
	}
	for i := range this.Values {
		if !bytes.Equal(this.Values[i], that1.Values[i]) {
			return false
		}
	}
	if !this.Subpartitioning.Equal(&that1.Subpartitioning) {
		return false
	}
	return true
}
func (this *PartitioningDescriptor_Range) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PartitioningDescriptor_Range)
	if !ok {
		that2, ok := that.(PartitioningDescriptor_Range)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if !bytes.Equal(this.FromInclusive, that1.FromInclusive) {
		return false
	}
	if !bytes.Equal(this.ToExclusive, that1.ToExclusive) {
		return false
	}
	return true
}
func (this *IndexDescriptor) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*IndexDescriptor)
	if !ok {
		that2, ok := that.(IndexDescriptor)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if this.Unique != that1.Unique {
		return false
	}
	if this.Version != that1.Version {
		return false
	}
	if len(this.ColumnNames) != len(that1.ColumnNames) {
		return false
	}
	for i := range this.ColumnNames {
		if this.ColumnNames[i] != that1.ColumnNames[i] {
			return false
		}
	}
	if len(this.ColumnDirections) != len(that1.ColumnDirections) {
		return false
	}
	for i := range this.ColumnDirections {
		if this.ColumnDirections[i] != that1.ColumnDirections[i] {
			return false
		}
	}
	if len(this.StoreColumnNames) != len(that1.StoreColumnNames) {
		return false
	}
	for i := range this.StoreColumnNames {
		if this.StoreColumnNames[i] != that1.StoreColumnNames[i] {
			return false
		}
	}
	if len(this.ColumnIDs) != len(that1.ColumnIDs) {
		return false
	}
	for i := range this.ColumnIDs {
		if this.ColumnIDs[i] != that1.ColumnIDs[i] {
			return false
		}
	}
	if len(this.ExtraColumnIDs) != len(that1.ExtraColumnIDs) {
		return false
	}
	for i := range this.ExtraColumnIDs {
		if this.ExtraColumnIDs[i] != that1.ExtraColumnIDs[i] {
			return false
		}
	}
	if len(this.StoreColumnIDs) != len(that1.StoreColumnIDs) {
		return false
	}
	for i := range this.StoreColumnIDs {
		if this.StoreColumnIDs[i] != that1.StoreColumnIDs[i] {
			return false
		}
	}
	if len(this.CompositeColumnIDs) != len(that1.CompositeColumnIDs) {
		return false
	}
	for i := range this.CompositeColumnIDs {
		if this.CompositeColumnIDs[i] != that1.CompositeColumnIDs[i] {
			return false
		}
	}
	if !this.ForeignKey.Equal(&that1.ForeignKey) {
		return false
	}
	if len(this.ReferencedBy) != len(that1.ReferencedBy) {
		return false
	}
	for i := range this.ReferencedBy {
		if !this.ReferencedBy[i].Equal(&that1.ReferencedBy[i]) {
			return false
		}
	}
	if !this.Interleave.Equal(&that1.Interleave) {
		return false
	}
	if len(this.InterleavedBy) != len(that1.InterleavedBy) {
		return false
	}
	for i := range this.InterleavedBy {
		if !this.InterleavedBy[i].Equal(&that1.InterleavedBy[i]) {
			return false
		}
	}
	if !this.Partitioning.Equal(&that1.Partitioning) {
		return false
	}
	if this.Type != that1.Type {
		return false
	}
	if this.CreatedExplicitly != that1.CreatedExplicitly {
		return false
	}
	if this.EncodingType != that1.EncodingType {
		return false
	}
	if !this.Sharded.Equal(&that1.Sharded) {
		return false
	}
	if this.Disabled != that1.Disabled {
		return false
	}
	if !this.GeoConfig.Equal(&that1.GeoConfig) {
		return false
	}
	if this.Predicate != that1.Predicate {
		return false
	}
	return true
}
func (this *ConstraintToUpdate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ConstraintToUpdate)
	if !ok {
		that2, ok := that.(ConstraintToUpdate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ConstraintType != that1.ConstraintType {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if !this.Check.Equal(&that1.Check) {
		return false
	}
	if !this.ForeignKey.Equal(&that1.ForeignKey) {
		return false
	}
	if this.NotNullColumn != that1.NotNullColumn {
		return false
	}
	return true
}
func (this *PrimaryKeySwap) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PrimaryKeySwap)
	if !ok {
		that2, ok := that.(PrimaryKeySwap)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.OldPrimaryIndexId != that1.OldPrimaryIndexId {
		return false
	}
	if this.NewPrimaryIndexId != that1.NewPrimaryIndexId {
		return false
	}
	if len(this.OldIndexes) != len(that1.OldIndexes) {
		return false
	}
	for i := range this.OldIndexes {
		if this.OldIndexes[i] != that1.OldIndexes[i] {
			return false
		}
	}
	if len(this.NewIndexes) != len(that1.NewIndexes) {
		return false
	}
	for i := range this.NewIndexes {
		if this.NewIndexes[i] != that1.NewIndexes[i] {
			return false
		}
	}
	return true
}
func (this *ComputedColumnSwap) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ComputedColumnSwap)
	if !ok {
		that2, ok := that.(ComputedColumnSwap)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.NewColumnId != that1.NewColumnId {
		return false
	}
	if this.OldColumnId != that1.OldColumnId {
		return false
	}
	return true
}
func (this *DescriptorMutation) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DescriptorMutation)
	if !ok {
		that2, ok := that.(DescriptorMutation)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.Descriptor_ == nil {
		if this.Descriptor_ != nil {
			return false
		}
	} else if this.Descriptor_ == nil {
		return false
	} else if !this.Descriptor_.Equal(that1.Descriptor_) {
		return false
	}
	if this.State != that1.State {
		return false
	}
	if this.Direction != that1.Direction {
		return false
	}
	if this.MutationID != that1.MutationID {
		return false
	}
	if this.Rollback != that1.Rollback {
		return false
	}
	return true
}
func (this *DescriptorMutation_Column) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DescriptorMutation_Column)
	if !ok {
		that2, ok := that.(DescriptorMutation_Column)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Column.Equal(that1.Column) {
		return false
	}
	return true
}
func (this *DescriptorMutation_Index) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DescriptorMutation_Index)
	if !ok {
		that2, ok := that.(DescriptorMutation_Index)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Index.Equal(that1.Index) {
		return false
	}
	return true
}
func (this *DescriptorMutation_Constraint) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DescriptorMutation_Constraint)
	if !ok {
		that2, ok := that.(DescriptorMutation_Constraint)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Constraint.Equal(that1.Constraint) {
		return false
	}
	return true
}
func (this *DescriptorMutation_PrimaryKeySwap) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DescriptorMutation_PrimaryKeySwap)
	if !ok {
		that2, ok := that.(DescriptorMutation_PrimaryKeySwap)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.PrimaryKeySwap.Equal(that1.PrimaryKeySwap) {
		return false
	}
	return true
}
func (this *DescriptorMutation_ComputedColumnSwap) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DescriptorMutation_ComputedColumnSwap)
	if !ok {
		that2, ok := that.(DescriptorMutation_ComputedColumnSwap)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ComputedColumnSwap.Equal(that1.ComputedColumnSwap) {
		return false
	}
	return true
}
func (this *TableDescriptor) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TableDescriptor)
	if !ok {
		that2, ok := that.(TableDescriptor)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if this.ParentID != that1.ParentID {
		return false
	}
	if this.UnexposedParentSchemaID != that1.UnexposedParentSchemaID {
		return false
	}
	if this.Version != that1.Version {
		return false
	}
	if !this.ModificationTime.Equal(&that1.ModificationTime) {
		return false
	}
	if len(this.Columns) != len(that1.Columns) {
		return false
	}
	for i := range this.Columns {
		if !this.Columns[i].Equal(&that1.Columns[i]) {
			return false
		}
	}
	if this.NextColumnID != that1.NextColumnID {
		return false
	}
	if len(this.Families) != len(that1.Families) {
		return false
	}
	for i := range this.Families {
		if !this.Families[i].Equal(&that1.Families[i]) {
			return false
		}
	}
	if this.NextFamilyID != that1.NextFamilyID {
		return false
	}
	if !this.PrimaryIndex.Equal(&that1.PrimaryIndex) {
		return false
	}
	if len(this.Indexes) != len(that1.Indexes) {
		return false
	}
	for i := range this.Indexes {
		if !this.Indexes[i].Equal(&that1.Indexes[i]) {
			return false
		}
	}
	if this.NextIndexID != that1.NextIndexID {
		return false
	}
	if !this.Privileges.Equal(that1.Privileges) {
		return false
	}
	if len(this.Mutations) != len(that1.Mutations) {
		return false
	}
	for i := range this.Mutations {
		if !this.Mutations[i].Equal(&that1.Mutations[i]) {
			return false
		}
	}
	if !this.Lease.Equal(that1.Lease) {
		return false
	}
	if this.NextMutationID != that1.NextMutationID {
		return false
	}
	if this.FormatVersion != that1.FormatVersion {
		return false
	}
	if this.State != that1.State {
		return false
	}
	if this.OfflineReason != that1.OfflineReason {
		return false
	}
	if len(this.Checks) != len(that1.Checks) {
		return false
	}
	for i := range this.Checks {
		if !this.Checks[i].Equal(that1.Checks[i]) {
			return false
		}
	}
	if len(this.DrainingNames) != len(that1.DrainingNames) {
		return false
	}
	for i := range this.DrainingNames {
		if !this.DrainingNames[i].Equal(&that1.DrainingNames[i]) {
			return false
		}
	}
	if this.ViewQuery != that1.ViewQuery {
		return false
	}
	if len(this.DependsOn) != len(that1.DependsOn) {
		return false
	}
	for i := range this.DependsOn {
		if this.DependsOn[i] != that1.DependsOn[i] {
			return false
		}
	}
	if len(this.DependedOnBy) != len(that1.DependedOnBy) {
		return false
	}
	for i := range this.DependedOnBy {
		if !this.DependedOnBy[i].Equal(&that1.DependedOnBy[i]) {
			return false
		}
	}
	if len(this.MutationJobs) != len(that1.MutationJobs) {
		return false
	}
	for i := range this.MutationJobs {
		if !this.MutationJobs[i].Equal(&that1.MutationJobs[i]) {
			return false
		}
	}
	if !this.SequenceOpts.Equal(that1.SequenceOpts) {
		return false
	}
	if this.DropTime != that1.DropTime {
		return false
	}
	if !this.ReplacementOf.Equal(&that1.ReplacementOf) {
		return false
	}
	if this.AuditMode != that1.AuditMode {
		return false
	}
	if this.DropJobID != that1.DropJobID {
		return false
	}
	if len(this.GCMutations) != len(that1.GCMutations) {
		return false
	}
	for i := range this.GCMutations {
		if !this.GCMutations[i].Equal(&that1.GCMutations[i]) {
			return false
		}
	}
	if this.CreateQuery != that1.CreateQuery {
		return false
	}
	if !this.CreateAsOfTime.Equal(&that1.CreateAsOfTime) {
		return false
	}
	if len(this.OutboundFKs) != len(that1.OutboundFKs) {
		return false
	}
	for i := range this.OutboundFKs {
		if !this.OutboundFKs[i].Equal(&that1.OutboundFKs[i]) {
			return false
		}
	}
	if len(this.InboundFKs) != len(that1.InboundFKs) {
		return false
	}
	for i := range this.InboundFKs {
		if !this.InboundFKs[i].Equal(&that1.InboundFKs[i]) {
			return false
		}
	}
	if this.Temporary != that1.Temporary {
		return false
	}
	return true
}
func (this *TableDescriptor_SchemaChangeLease) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TableDescriptor_SchemaChangeLease)
	if !ok {
		that2, ok := that.(TableDescriptor_SchemaChangeLease)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.NodeID != that1.NodeID {
		return false
	}
	if this.ExpirationTime != that1.ExpirationTime {
		return false
	}
	return true
}
func (this *TableDescriptor_CheckConstraint) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TableDescriptor_CheckConstraint)
	if !ok {
		that2, ok := that.(TableDescriptor_CheckConstraint)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Expr != that1.Expr {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Validity != that1.Validity {
		return false
	}
	if len(this.ColumnIDs) != len(that1.ColumnIDs) {
		return false
	}
	for i := range this.ColumnIDs {
		if this.ColumnIDs[i] != that1.ColumnIDs[i] {
			return false
		}
	}
	if this.IsNonNullConstraint != that1.IsNonNullConstraint {
		return false
	}
	if this.Hidden != that1.Hidden {
		return false
	}
	return true
}
func (this *TableDescriptor_NameInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TableDescriptor_NameInfo)
	if !ok {
		that2, ok := that.(TableDescriptor_NameInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ParentID != that1.ParentID {
		return false
	}
	if this.ParentSchemaID != that1.ParentSchemaID {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	return true
}
func (this *TableDescriptor_Reference) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TableDescriptor_Reference)
	if !ok {
		that2, ok := that.(TableDescriptor_Reference)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if this.IndexID != that1.IndexID {
		return false
	}
	if len(this.ColumnIDs) != len(that1.ColumnIDs) {
		return false
	}
	for i := range this.ColumnIDs {
		if this.ColumnIDs[i] != that1.ColumnIDs[i] {
			return false
		}
	}
	return true
}
func (this *TableDescriptor_MutationJob) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TableDescriptor_MutationJob)
	if !ok {
		that2, ok := that.(TableDescriptor_MutationJob)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.MutationID != that1.MutationID {
		return false
	}
	if this.JobID != that1.JobID {
		return false
	}
	return true
}
func (this *TableDescriptor_SequenceOpts) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TableDescriptor_SequenceOpts)
	if !ok {
		that2, ok := that.(TableDescriptor_SequenceOpts)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Increment != that1.Increment {
		return false
	}
	if this.MinValue != that1.MinValue {
		return false
	}
	if this.MaxValue != that1.MaxValue {
		return false
	}
	if this.Start != that1.Start {
		return false
	}
	if this.Virtual != that1.Virtual {
		return false
	}
	if !this.SequenceOwner.Equal(&that1.SequenceOwner) {
		return false
	}
	return true
}
func (this *TableDescriptor_SequenceOpts_SequenceOwner) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TableDescriptor_SequenceOpts_SequenceOwner)
	if !ok {
		that2, ok := that.(TableDescriptor_SequenceOpts_SequenceOwner)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.OwnerColumnID != that1.OwnerColumnID {
		return false
	}
	if this.OwnerTableID != that1.OwnerTableID {
		return false
	}
	return true
}
func (this *TableDescriptor_Replacement) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TableDescriptor_Replacement)
	if !ok {
		that2, ok := that.(TableDescriptor_Replacement)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if !this.Time.Equal(&that1.Time) {
		return false
	}
	return true
}
func (this *TableDescriptor_GCDescriptorMutation) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TableDescriptor_GCDescriptorMutation)
	if !ok {
		that2, ok := that.(TableDescriptor_GCDescriptorMutation)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.IndexID != that1.IndexID {
		return false
	}
	if this.DropTime != that1.DropTime {
		return false
	}
	if this.JobID != that1.JobID {
		return false
	}
	return true
}
func (this *DatabaseDescriptor) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DatabaseDescriptor)
	if !ok {
		that2, ok := that.(DatabaseDescriptor)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if !this.Privileges.Equal(that1.Privileges) {
		return false
	}
	return true
}
func (this *TypeDescriptor) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TypeDescriptor)
	if !ok {
		that2, ok := that.(TypeDescriptor)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ParentID != that1.ParentID {
		return false
	}
	if this.ParentSchemaID != that1.ParentSchemaID {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if this.ArrayTypeID != that1.ArrayTypeID {
		return false
	}
	if this.Kind != that1.Kind {
		return false
	}
	if len(this.EnumMembers) != len(that1.EnumMembers) {
		return false
	}
	for i := range this.EnumMembers {
		if !this.EnumMembers[i].Equal(&that1.EnumMembers[i]) {
			return false
		}
	}
	if !this.Alias.Equal(that1.Alias) {
		return false
	}
	return true
}
func (this *TypeDescriptor_EnumMember) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TypeDescriptor_EnumMember)
	if !ok {
		that2, ok := that.(TypeDescriptor_EnumMember)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.PhysicalRepresentation, that1.PhysicalRepresentation) {
		return false
	}
	if this.LogicalRepresentation != that1.LogicalRepresentation {
		return false
	}
	return true
}
func (this *SchemaDescriptor) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SchemaDescriptor)
	if !ok {
		that2, ok := that.(SchemaDescriptor)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ParentID != that1.ParentID {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if !this.Privileges.Equal(that1.Privileges) {
		return false
	}
	return true
}
func (this *Descriptor) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Descriptor)
	if !ok {
		that2, ok := that.(Descriptor)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.Union == nil {
		if this.Union != nil {
			return false
		}
	} else if this.Union == nil {
		return false
	} else if !this.Union.Equal(that1.Union) {
		return false
	}
	return true
}
func (this *Descriptor_Table) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Descriptor_Table)
	if !ok {
		that2, ok := that.(Descriptor_Table)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Table.Equal(that1.Table) {
		return false
	}
	return true
}
func (this *Descriptor_Database) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Descriptor_Database)
	if !ok {
		that2, ok := that.(Descriptor_Database)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Database.Equal(that1.Database) {
		return false
	}
	return true
}
func (this *Descriptor_Type) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Descriptor_Type)
	if !ok {
		that2, ok := that.(Descriptor_Type)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Type.Equal(that1.Type) {
		return false
	}
	return true
}
func (this *Descriptor_Schema) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Descriptor_Schema)
	if !ok {
		that2, ok := that.(Descriptor_Schema)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Schema.Equal(that1.Schema) {
		return false
	}
	return true
}
func (m *ForeignKeyReference) 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 *ForeignKeyReference) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.Table))
	dAtA[i] = 0x10
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.Index))
	dAtA[i] = 0x1a
	i++
	i = encodeVarintStructured(dAtA, i, uint64(len(m.Name)))
	i += copy(dAtA[i:], m.Name)
	dAtA[i] = 0x20
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.Validity))
	dAtA[i] = 0x28
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.SharedPrefixLen))
	dAtA[i] = 0x30
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.OnDelete))
	dAtA[i] = 0x38
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.OnUpdate))
	dAtA[i] = 0x40
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.Match))
	return i, nil
}

func (m *ForeignKeyConstraint) 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 *ForeignKeyConstraint) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.OriginTableID))
	if len(m.OriginColumnIDs) > 0 {
		for _, num := range m.OriginColumnIDs {
			dAtA[i] = 0x10
			i++
			i = encodeVarintStructured(dAtA, i, uint64(num))
		}
	}
	if len(m.ReferencedColumnIDs) > 0 {
		for _, num := range m.ReferencedColumnIDs {
			dAtA[i] = 0x18
			i++
			i = encodeVarintStructured(dAtA, i, uint64(num))
		}
	}
	dAtA[i] = 0x20
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ReferencedTableID))
	dAtA[i] = 0x2a
	i++
	i = encodeVarintStructured(dAtA, i, uint64(len(m.Name)))
	i += copy(dAtA[i:], m.Name)
	dAtA[i] = 0x30
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.Validity))
	dAtA[i] = 0x38
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.OnDelete))
	dAtA[i] = 0x40
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.OnUpdate))
	dAtA[i] = 0x48
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.Match))
	dAtA[i] = 0x50
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.LegacyOriginIndex))
	dAtA[i] = 0x58
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.LegacyReferencedIndex))
	return i, nil
}

func (m *ColumnDescriptor) 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 *ColumnDescriptor) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintStructured(dAtA, i, uint64(len(m.Name)))
	i += copy(dAtA[i:], m.Name)
	dAtA[i] = 0x10
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ID))
	if m.Type != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintStructured(dAtA, i, uint64(m.Type.Size()))
		n1, err := m.Type.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	dAtA[i] = 0x20
	i++
	if m.Nullable {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	if m.DefaultExpr != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintStructured(dAtA, i, uint64(len(*m.DefaultExpr)))
		i += copy(dAtA[i:], *m.DefaultExpr)
	}
	dAtA[i] = 0x30
	i++
	if m.Hidden {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	if len(m.UsesSequenceIds) > 0 {
		for _, num := range m.UsesSequenceIds {
			dAtA[i] = 0x50
			i++
			i = encodeVarintStructured(dAtA, i, uint64(num))
		}
	}
	if m.ComputeExpr != nil {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintStructured(dAtA, i, uint64(len(*m.ComputeExpr)))
		i += copy(dAtA[i:], *m.ComputeExpr)
	}
	if len(m.OwnsSequenceIds) > 0 {
		for _, num := range m.OwnsSequenceIds {
			dAtA[i] = 0x60
			i++
			i = encodeVarintStructured(dAtA, i, uint64(num))
		}
	}
	dAtA[i] = 0x68
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.LogicalColumnID))
	dAtA[i] = 0x70
	i++
	if m.AlterColumnTypeInProgress {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	return i, nil
}

func (m *ColumnFamilyDescriptor) 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 *ColumnFamilyDescriptor) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintStructured(dAtA, i, uint64(len(m.Name)))
	i += copy(dAtA[i:], m.Name)
	dAtA[i] = 0x10
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ID))
	if len(m.ColumnNames) > 0 {
		for _, s := range m.ColumnNames {
			dAtA[i] = 0x1a
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.ColumnIDs) > 0 {
		for _, num := range m.ColumnIDs {
			dAtA[i] = 0x20
			i++
			i = encodeVarintStructured(dAtA, i, uint64(num))
		}
	}
	dAtA[i] = 0x28
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.DefaultColumnID))
	return i, nil
}

func (m *InterleaveDescriptor) 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 *InterleaveDescriptor) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Ancestors) > 0 {
		for _, msg := range m.Ancestors {
			dAtA[i] = 0xa
			i++
			i = encodeVarintStructured(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *InterleaveDescriptor_Ancestor) 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 *InterleaveDescriptor_Ancestor) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.TableID))
	dAtA[i] = 0x10
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.IndexID))
	dAtA[i] = 0x18
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.SharedPrefixLen))
	return i, nil
}

func (m *ShardedDescriptor) 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 *ShardedDescriptor) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	if m.IsSharded {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	dAtA[i] = 0x12
	i++
	i = encodeVarintStructured(dAtA, i, uint64(len(m.Name)))
	i += copy(dAtA[i:], m.Name)
	dAtA[i] = 0x18
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ShardBuckets))
	if len(m.ColumnNames) > 0 {
		for _, s := range m.ColumnNames {
			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 *PartitioningDescriptor) 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 *PartitioningDescriptor) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.NumColumns))
	if len(m.List) > 0 {
		for _, msg := range m.List {
			dAtA[i] = 0x12
			i++
			i = encodeVarintStructured(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Range) > 0 {
		for _, msg := range m.Range {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintStructured(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *PartitioningDescriptor_List) 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 *PartitioningDescriptor_List) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintStructured(dAtA, i, uint64(len(m.Name)))
	i += copy(dAtA[i:], m.Name)
	if len(m.Values) > 0 {
		for _, b := range m.Values {
			dAtA[i] = 0x12
			i++
			i = encodeVarintStructured(dAtA, i, uint64(len(b)))
			i += copy(dAtA[i:], b)
		}
	}
	dAtA[i] = 0x1a
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.Subpartitioning.Size()))
	n2, err := m.Subpartitioning.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n2
	return i, nil
}

func (m *PartitioningDescriptor_Range) 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 *PartitioningDescriptor_Range) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintStructured(dAtA, i, uint64(len(m.Name)))
	i += copy(dAtA[i:], m.Name)
	if m.ToExclusive != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintStructured(dAtA, i, uint64(len(m.ToExclusive)))
		i += copy(dAtA[i:], m.ToExclusive)
	}
	if m.FromInclusive != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintStructured(dAtA, i, uint64(len(m.FromInclusive)))
		i += copy(dAtA[i:], m.FromInclusive)
	}
	return i, nil
}

func (m *IndexDescriptor) 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 *IndexDescriptor) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintStructured(dAtA, i, uint64(len(m.Name)))
	i += copy(dAtA[i:], m.Name)
	dAtA[i] = 0x10
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ID))
	dAtA[i] = 0x18
	i++
	if m.Unique {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	if len(m.ColumnNames) > 0 {
		for _, s := range m.ColumnNames {
			dAtA[i] = 0x22
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.StoreColumnNames) > 0 {
		for _, s := range m.StoreColumnNames {
			dAtA[i] = 0x2a
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.ColumnIDs) > 0 {
		for _, num := range m.ColumnIDs {
			dAtA[i] = 0x30
			i++
			i = encodeVarintStructured(dAtA, i, uint64(num))
		}
	}
	if len(m.ExtraColumnIDs) > 0 {
		for _, num := range m.ExtraColumnIDs {
			dAtA[i] = 0x38
			i++
			i = encodeVarintStructured(dAtA, i, uint64(num))
		}
	}
	if len(m.ColumnDirections) > 0 {
		for _, num := range m.ColumnDirections {
			dAtA[i] = 0x40
			i++
			i = encodeVarintStructured(dAtA, i, uint64(num))
		}
	}
	dAtA[i] = 0x4a
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ForeignKey.Size()))
	n3, err := m.ForeignKey.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n3
	if len(m.ReferencedBy) > 0 {
		for _, msg := range m.ReferencedBy {
			dAtA[i] = 0x52
			i++
			i = encodeVarintStructured(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	dAtA[i] = 0x5a
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.Interleave.Size()))
	n4, err := m.Interleave.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n4
	if len(m.InterleavedBy) > 0 {
		for _, msg := range m.InterleavedBy {
			dAtA[i] = 0x62
			i++
			i = encodeVarintStructured(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.CompositeColumnIDs) > 0 {
		for _, num := range m.CompositeColumnIDs {
			dAtA[i] = 0x68
			i++
			i = encodeVarintStructured(dAtA, i, uint64(num))
		}
	}
	if len(m.StoreColumnIDs) > 0 {
		for _, num := range m.StoreColumnIDs {
			dAtA[i] = 0x70
			i++
			i = encodeVarintStructured(dAtA, i, uint64(num))
		}
	}
	dAtA[i] = 0x7a
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.Partitioning.Size()))
	n5, err := m.Partitioning.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n5
	dAtA[i] = 0x80
	i++
	dAtA[i] = 0x1
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.Type))
	dAtA[i] = 0x88
	i++
	dAtA[i] = 0x1
	i++
	if m.CreatedExplicitly {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	dAtA[i] = 0x90
	i++
	dAtA[i] = 0x1
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.Version))
	dAtA[i] = 0x98
	i++
	dAtA[i] = 0x1
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.EncodingType))
	dAtA[i] = 0xa2
	i++
	dAtA[i] = 0x1
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.Sharded.Size()))
	n6, err := m.Sharded.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n6
	dAtA[i] = 0xa8
	i++
	dAtA[i] = 0x1
	i++
	if m.Disabled {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	dAtA[i] = 0xb2
	i++
	dAtA[i] = 0x1
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.GeoConfig.Size()))
	n7, err := m.GeoConfig.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n7
	dAtA[i] = 0xba
	i++
	dAtA[i] = 0x1
	i++
	i = encodeVarintStructured(dAtA, i, uint64(len(m.Predicate)))
	i += copy(dAtA[i:], m.Predicate)
	return i, nil
}

func (m *ConstraintToUpdate) 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 *ConstraintToUpdate) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ConstraintType))
	dAtA[i] = 0x12
	i++
	i = encodeVarintStructured(dAtA, i, uint64(len(m.Name)))
	i += copy(dAtA[i:], m.Name)
	dAtA[i] = 0x1a
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.Check.Size()))
	n8, err := m.Check.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n8
	dAtA[i] = 0x22
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ForeignKey.Size()))
	n9, err := m.ForeignKey.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n9
	dAtA[i] = 0x30
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.NotNullColumn))
	return i, nil
}

func (m *PrimaryKeySwap) 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 *PrimaryKeySwap) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.NewPrimaryIndexId))
	if len(m.OldIndexes) > 0 {
		for _, num := range m.OldIndexes {
			dAtA[i] = 0x10
			i++
			i = encodeVarintStructured(dAtA, i, uint64(num))
		}
	}
	if len(m.NewIndexes) > 0 {
		for _, num := range m.NewIndexes {
			dAtA[i] = 0x18
			i++
			i = encodeVarintStructured(dAtA, i, uint64(num))
		}
	}
	dAtA[i] = 0x20
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.OldPrimaryIndexId))
	return i, nil
}

func (m *ComputedColumnSwap) 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 *ComputedColumnSwap) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.NewColumnId))
	dAtA[i] = 0x10
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.OldColumnId))
	return i, nil
}

func (m *DescriptorMutation) 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 *DescriptorMutation) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Descriptor_ != nil {
		nn10, err := m.Descriptor_.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn10
	}
	dAtA[i] = 0x18
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.State))
	dAtA[i] = 0x20
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.Direction))
	dAtA[i] = 0x28
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.MutationID))
	dAtA[i] = 0x38
	i++
	if m.Rollback {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	return i, nil
}

func (m *DescriptorMutation_Column) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Column != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintStructured(dAtA, i, uint64(m.Column.Size()))
		n11, err := m.Column.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n11
	}
	return i, nil
}
func (m *DescriptorMutation_Index) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Index != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintStructured(dAtA, i, uint64(m.Index.Size()))
		n12, err := m.Index.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	return i, nil
}
func (m *DescriptorMutation_Constraint) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Constraint != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintStructured(dAtA, i, uint64(m.Constraint.Size()))
		n13, err := m.Constraint.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n13
	}
	return i, nil
}
func (m *DescriptorMutation_PrimaryKeySwap) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.PrimaryKeySwap != nil {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintStructured(dAtA, i, uint64(m.PrimaryKeySwap.Size()))
		n14, err := m.PrimaryKeySwap.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n14
	}
	return i, nil
}
func (m *DescriptorMutation_ComputedColumnSwap) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ComputedColumnSwap != nil {
		dAtA[i] = 0x52
		i++
		i = encodeVarintStructured(dAtA, i, uint64(m.ComputedColumnSwap.Size()))
		n15, err := m.ComputedColumnSwap.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n15
	}
	return i, nil
}
func (m *TableDescriptor) 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 *TableDescriptor) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintStructured(dAtA, i, uint64(len(m.Name)))
	i += copy(dAtA[i:], m.Name)
	dAtA[i] = 0x18
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ID))
	dAtA[i] = 0x20
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ParentID))
	dAtA[i] = 0x28
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.Version))
	dAtA[i] = 0x3a
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ModificationTime.Size()))
	n16, err := m.ModificationTime.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n16
	if len(m.Columns) > 0 {
		for _, msg := range m.Columns {
			dAtA[i] = 0x42
			i++
			i = encodeVarintStructured(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	dAtA[i] = 0x48
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.NextColumnID))
	dAtA[i] = 0x52
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.PrimaryIndex.Size()))
	n17, err := m.PrimaryIndex.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n17
	if len(m.Indexes) > 0 {
		for _, msg := range m.Indexes {
			dAtA[i] = 0x5a
			i++
			i = encodeVarintStructured(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	dAtA[i] = 0x60
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.NextIndexID))
	if m.Privileges != nil {
		dAtA[i] = 0x6a
		i++
		i = encodeVarintStructured(dAtA, i, uint64(m.Privileges.Size()))
		n18, err := m.Privileges.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n18
	}
	if len(m.Mutations) > 0 {
		for _, msg := range m.Mutations {
			dAtA[i] = 0x72
			i++
			i = encodeVarintStructured(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.Lease != nil {
		dAtA[i] = 0x7a
		i++
		i = encodeVarintStructured(dAtA, i, uint64(m.Lease.Size()))
		n19, err := m.Lease.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n19
	}
	dAtA[i] = 0x80
	i++
	dAtA[i] = 0x1
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.NextMutationID))
	dAtA[i] = 0x88
	i++
	dAtA[i] = 0x1
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.FormatVersion))
	dAtA[i] = 0x98
	i++
	dAtA[i] = 0x1
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.State))
	if len(m.Checks) > 0 {
		for _, msg := range m.Checks {
			dAtA[i] = 0xa2
			i++
			dAtA[i] = 0x1
			i++
			i = encodeVarintStructured(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.DrainingNames) > 0 {
		for _, msg := range m.DrainingNames {
			dAtA[i] = 0xaa
			i++
			dAtA[i] = 0x1
			i++
			i = encodeVarintStructured(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Families) > 0 {
		for _, msg := range m.Families {
			dAtA[i] = 0xb2
			i++
			dAtA[i] = 0x1
			i++
			i = encodeVarintStructured(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	dAtA[i] = 0xb8
	i++
	dAtA[i] = 0x1
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.NextFamilyID))
	dAtA[i] = 0xc2
	i++
	dAtA[i] = 0x1
	i++
	i = encodeVarintStructured(dAtA, i, uint64(len(m.ViewQuery)))
	i += copy(dAtA[i:], m.ViewQuery)
	if len(m.DependsOn) > 0 {
		for _, num := range m.DependsOn {
			dAtA[i] = 0xc8
			i++
			dAtA[i] = 0x1
			i++
			i = encodeVarintStructured(dAtA, i, uint64(num))
		}
	}
	if len(m.DependedOnBy) > 0 {
		for _, msg := range m.DependedOnBy {
			dAtA[i] = 0xd2
			i++
			dAtA[i] = 0x1
			i++
			i = encodeVarintStructured(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.MutationJobs) > 0 {
		for _, msg := range m.MutationJobs {
			dAtA[i] = 0xda
			i++
			dAtA[i] = 0x1
			i++
			i = encodeVarintStructured(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.SequenceOpts != nil {
		dAtA[i] = 0xe2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintStructured(dAtA, i, uint64(m.SequenceOpts.Size()))
		n20, err := m.SequenceOpts.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n20
	}
	dAtA[i] = 0xe8
	i++
	dAtA[i] = 0x1
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.DropTime))
	dAtA[i] = 0xf2
	i++
	dAtA[i] = 0x1
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ReplacementOf.Size()))
	n21, err := m.ReplacementOf.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n21
	dAtA[i] = 0xf8
	i++
	dAtA[i] = 0x1
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.AuditMode))
	dAtA[i] = 0x80
	i++
	dAtA[i] = 0x2
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.DropJobID))
	if len(m.GCMutations) > 0 {
		for _, msg := range m.GCMutations {
			dAtA[i] = 0x8a
			i++
			dAtA[i] = 0x2
			i++
			i = encodeVarintStructured(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	dAtA[i] = 0x92
	i++
	dAtA[i] = 0x2
	i++
	i = encodeVarintStructured(dAtA, i, uint64(len(m.CreateQuery)))
	i += copy(dAtA[i:], m.CreateQuery)
	dAtA[i] = 0x9a
	i++
	dAtA[i] = 0x2
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.CreateAsOfTime.Size()))
	n22, err := m.CreateAsOfTime.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n22
	if len(m.OutboundFKs) > 0 {
		for _, msg := range m.OutboundFKs {
			dAtA[i] = 0xa2
			i++
			dAtA[i] = 0x2
			i++
			i = encodeVarintStructured(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.InboundFKs) > 0 {
		for _, msg := range m.InboundFKs {
			dAtA[i] = 0xaa
			i++
			dAtA[i] = 0x2
			i++
			i = encodeVarintStructured(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	dAtA[i] = 0xb2
	i++
	dAtA[i] = 0x2
	i++
	i = encodeVarintStructured(dAtA, i, uint64(len(m.OfflineReason)))
	i += copy(dAtA[i:], m.OfflineReason)
	dAtA[i] = 0xb8
	i++
	dAtA[i] = 0x2
	i++
	if m.Temporary {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	dAtA[i] = 0xc0
	i++
	dAtA[i] = 0x2
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.UnexposedParentSchemaID))
	return i, nil
}

func (m *TableDescriptor_SchemaChangeLease) 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 *TableDescriptor_SchemaChangeLease) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.NodeID))
	dAtA[i] = 0x10
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ExpirationTime))
	return i, nil
}

func (m *TableDescriptor_CheckConstraint) 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 *TableDescriptor_CheckConstraint) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintStructured(dAtA, i, uint64(len(m.Expr)))
	i += copy(dAtA[i:], m.Expr)
	dAtA[i] = 0x12
	i++
	i = encodeVarintStructured(dAtA, i, uint64(len(m.Name)))
	i += copy(dAtA[i:], m.Name)
	dAtA[i] = 0x18
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.Validity))
	if len(m.ColumnIDs) > 0 {
		for _, num := range m.ColumnIDs {
			dAtA[i] = 0x28
			i++
			i = encodeVarintStructured(dAtA, i, uint64(num))
		}
	}
	dAtA[i] = 0x30
	i++
	if m.IsNonNullConstraint {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	dAtA[i] = 0x38
	i++
	if m.Hidden {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	return i, nil
}

func (m *TableDescriptor_NameInfo) 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 *TableDescriptor_NameInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ParentID))
	dAtA[i] = 0x12
	i++
	i = encodeVarintStructured(dAtA, i, uint64(len(m.Name)))
	i += copy(dAtA[i:], m.Name)
	dAtA[i] = 0x18
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ParentSchemaID))
	return i, nil
}

func (m *TableDescriptor_Reference) 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 *TableDescriptor_Reference) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ID))
	dAtA[i] = 0x10
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.IndexID))
	if len(m.ColumnIDs) > 0 {
		for _, num := range m.ColumnIDs {
			dAtA[i] = 0x18
			i++
			i = encodeVarintStructured(dAtA, i, uint64(num))
		}
	}
	return i, nil
}

func (m *TableDescriptor_MutationJob) 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 *TableDescriptor_MutationJob) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.MutationID))
	dAtA[i] = 0x10
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.JobID))
	return i, nil
}

func (m *TableDescriptor_SequenceOpts) 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 *TableDescriptor_SequenceOpts) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.Increment))
	dAtA[i] = 0x10
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.MinValue))
	dAtA[i] = 0x18
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.MaxValue))
	dAtA[i] = 0x20
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.Start))
	dAtA[i] = 0x28
	i++
	if m.Virtual {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	dAtA[i] = 0x32
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.SequenceOwner.Size()))
	n23, err := m.SequenceOwner.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n23
	return i, nil
}

func (m *TableDescriptor_SequenceOpts_SequenceOwner) 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 *TableDescriptor_SequenceOpts_SequenceOwner) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.OwnerColumnID))
	dAtA[i] = 0x10
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.OwnerTableID))
	return i, nil
}

func (m *TableDescriptor_Replacement) 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 *TableDescriptor_Replacement) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ID))
	dAtA[i] = 0x12
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.Time.Size()))
	n24, err := m.Time.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n24
	return i, nil
}

func (m *TableDescriptor_GCDescriptorMutation) 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 *TableDescriptor_GCDescriptorMutation) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.IndexID))
	dAtA[i] = 0x10
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.DropTime))
	dAtA[i] = 0x18
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.JobID))
	return i, nil
}

func (m *DatabaseDescriptor) 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 *DatabaseDescriptor) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintStructured(dAtA, i, uint64(len(m.Name)))
	i += copy(dAtA[i:], m.Name)
	dAtA[i] = 0x10
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ID))
	if m.Privileges != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintStructured(dAtA, i, uint64(m.Privileges.Size()))
		n25, err := m.Privileges.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n25
	}
	return i, nil
}

func (m *TypeDescriptor) 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 *TypeDescriptor) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ParentID))
	dAtA[i] = 0x10
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ParentSchemaID))
	dAtA[i] = 0x1a
	i++
	i = encodeVarintStructured(dAtA, i, uint64(len(m.Name)))
	i += copy(dAtA[i:], m.Name)
	dAtA[i] = 0x20
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ID))
	dAtA[i] = 0x28
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.Kind))
	if len(m.EnumMembers) > 0 {
		for _, msg := range m.EnumMembers {
			dAtA[i] = 0x32
			i++
			i = encodeVarintStructured(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.Alias != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintStructured(dAtA, i, uint64(m.Alias.Size()))
		n26, err := m.Alias.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n26
	}
	dAtA[i] = 0x40
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ArrayTypeID))
	return i, nil
}

func (m *TypeDescriptor_EnumMember) 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 *TypeDescriptor_EnumMember) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.PhysicalRepresentation != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintStructured(dAtA, i, uint64(len(m.PhysicalRepresentation)))
		i += copy(dAtA[i:], m.PhysicalRepresentation)
	}
	dAtA[i] = 0x12
	i++
	i = encodeVarintStructured(dAtA, i, uint64(len(m.LogicalRepresentation)))
	i += copy(dAtA[i:], m.LogicalRepresentation)
	return i, nil
}

func (m *SchemaDescriptor) 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 *SchemaDescriptor) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ParentID))
	dAtA[i] = 0x12
	i++
	i = encodeVarintStructured(dAtA, i, uint64(len(m.Name)))
	i += copy(dAtA[i:], m.Name)
	dAtA[i] = 0x18
	i++
	i = encodeVarintStructured(dAtA, i, uint64(m.ID))
	if m.Privileges != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintStructured(dAtA, i, uint64(m.Privileges.Size()))
		n27, err := m.Privileges.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n27
	}
	return i, nil
}

func (m *Descriptor) 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 *Descriptor) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Union != nil {
		nn28, err := m.Union.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn28
	}
	return i, nil
}

func (m *Descriptor_Table) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Table != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintStructured(dAtA, i, uint64(m.Table.Size()))
		n29, err := m.Table.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n29
	}
	return i, nil
}
func (m *Descriptor_Database) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Database != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintStructured(dAtA, i, uint64(m.Database.Size()))
		n30, err := m.Database.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n30
	}
	return i, nil
}
func (m *Descriptor_Type) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Type != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintStructured(dAtA, i, uint64(m.Type.Size()))
		n31, err := m.Type.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n31
	}
	return i, nil
}
func (m *Descriptor_Schema) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Schema != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintStructured(dAtA, i, uint64(m.Schema.Size()))
		n32, err := m.Schema.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n32
	}
	return i, nil
}
func encodeVarintStructured(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 *ForeignKeyReference) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovStructured(uint64(m.Table))
	n += 1 + sovStructured(uint64(m.Index))
	l = len(m.Name)
	n += 1 + l + sovStructured(uint64(l))
	n += 1 + sovStructured(uint64(m.Validity))
	n += 1 + sovStructured(uint64(m.SharedPrefixLen))
	n += 1 + sovStructured(uint64(m.OnDelete))
	n += 1 + sovStructured(uint64(m.OnUpdate))
	n += 1 + sovStructured(uint64(m.Match))
	return n
}

func (m *ForeignKeyConstraint) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovStructured(uint64(m.OriginTableID))
	if len(m.OriginColumnIDs) > 0 {
		for _, e := range m.OriginColumnIDs {
			n += 1 + sovStructured(uint64(e))
		}
	}
	if len(m.ReferencedColumnIDs) > 0 {
		for _, e := range m.ReferencedColumnIDs {
			n += 1 + sovStructured(uint64(e))
		}
	}
	n += 1 + sovStructured(uint64(m.ReferencedTableID))
	l = len(m.Name)
	n += 1 + l + sovStructured(uint64(l))
	n += 1 + sovStructured(uint64(m.Validity))
	n += 1 + sovStructured(uint64(m.OnDelete))
	n += 1 + sovStructured(uint64(m.OnUpdate))
	n += 1 + sovStructured(uint64(m.Match))
	n += 1 + sovStructured(uint64(m.LegacyOriginIndex))
	n += 1 + sovStructured(uint64(m.LegacyReferencedIndex))
	return n
}

func (m *ColumnDescriptor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovStructured(uint64(l))
	n += 1 + sovStructured(uint64(m.ID))
	if m.Type != nil {
		l = m.Type.Size()
		n += 1 + l + sovStructured(uint64(l))
	}
	n += 2
	if m.DefaultExpr != nil {
		l = len(*m.DefaultExpr)
		n += 1 + l + sovStructured(uint64(l))
	}
	n += 2
	if len(m.UsesSequenceIds) > 0 {
		for _, e := range m.UsesSequenceIds {
			n += 1 + sovStructured(uint64(e))
		}
	}
	if m.ComputeExpr != nil {
		l = len(*m.ComputeExpr)
		n += 1 + l + sovStructured(uint64(l))
	}
	if len(m.OwnsSequenceIds) > 0 {
		for _, e := range m.OwnsSequenceIds {
			n += 1 + sovStructured(uint64(e))
		}
	}
	n += 1 + sovStructured(uint64(m.LogicalColumnID))
	n += 2
	return n
}

func (m *ColumnFamilyDescriptor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovStructured(uint64(l))
	n += 1 + sovStructured(uint64(m.ID))
	if len(m.ColumnNames) > 0 {
		for _, s := range m.ColumnNames {
			l = len(s)
			n += 1 + l + sovStructured(uint64(l))
		}
	}
	if len(m.ColumnIDs) > 0 {
		for _, e := range m.ColumnIDs {
			n += 1 + sovStructured(uint64(e))
		}
	}
	n += 1 + sovStructured(uint64(m.DefaultColumnID))
	return n
}

func (m *InterleaveDescriptor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Ancestors) > 0 {
		for _, e := range m.Ancestors {
			l = e.Size()
			n += 1 + l + sovStructured(uint64(l))
		}
	}
	return n
}

func (m *InterleaveDescriptor_Ancestor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovStructured(uint64(m.TableID))
	n += 1 + sovStructured(uint64(m.IndexID))
	n += 1 + sovStructured(uint64(m.SharedPrefixLen))
	return n
}

func (m *ShardedDescriptor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2
	l = len(m.Name)
	n += 1 + l + sovStructured(uint64(l))
	n += 1 + sovStructured(uint64(m.ShardBuckets))
	if len(m.ColumnNames) > 0 {
		for _, s := range m.ColumnNames {
			l = len(s)
			n += 1 + l + sovStructured(uint64(l))
		}
	}
	return n
}

func (m *PartitioningDescriptor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovStructured(uint64(m.NumColumns))
	if len(m.List) > 0 {
		for _, e := range m.List {
			l = e.Size()
			n += 1 + l + sovStructured(uint64(l))
		}
	}
	if len(m.Range) > 0 {
		for _, e := range m.Range {
			l = e.Size()
			n += 1 + l + sovStructured(uint64(l))
		}
	}
	return n
}

func (m *PartitioningDescriptor_List) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovStructured(uint64(l))
	if len(m.Values) > 0 {
		for _, b := range m.Values {
			l = len(b)
			n += 1 + l + sovStructured(uint64(l))
		}
	}
	l = m.Subpartitioning.Size()
	n += 1 + l + sovStructured(uint64(l))
	return n
}

func (m *PartitioningDescriptor_Range) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovStructured(uint64(l))
	if m.ToExclusive != nil {
		l = len(m.ToExclusive)
		n += 1 + l + sovStructured(uint64(l))
	}
	if m.FromInclusive != nil {
		l = len(m.FromInclusive)
		n += 1 + l + sovStructured(uint64(l))
	}
	return n
}

func (m *IndexDescriptor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovStructured(uint64(l))
	n += 1 + sovStructured(uint64(m.ID))
	n += 2
	if len(m.ColumnNames) > 0 {
		for _, s := range m.ColumnNames {
			l = len(s)
			n += 1 + l + sovStructured(uint64(l))
		}
	}
	if len(m.StoreColumnNames) > 0 {
		for _, s := range m.StoreColumnNames {
			l = len(s)
			n += 1 + l + sovStructured(uint64(l))
		}
	}
	if len(m.ColumnIDs) > 0 {
		for _, e := range m.ColumnIDs {
			n += 1 + sovStructured(uint64(e))
		}
	}
	if len(m.ExtraColumnIDs) > 0 {
		for _, e := range m.ExtraColumnIDs {
			n += 1 + sovStructured(uint64(e))
		}
	}
	if len(m.ColumnDirections) > 0 {
		for _, e := range m.ColumnDirections {
			n += 1 + sovStructured(uint64(e))
		}
	}
	l = m.ForeignKey.Size()
	n += 1 + l + sovStructured(uint64(l))
	if len(m.ReferencedBy) > 0 {
		for _, e := range m.ReferencedBy {
			l = e.Size()
			n += 1 + l + sovStructured(uint64(l))
		}
	}
	l = m.Interleave.Size()
	n += 1 + l + sovStructured(uint64(l))
	if len(m.InterleavedBy) > 0 {
		for _, e := range m.InterleavedBy {
			l = e.Size()
			n += 1 + l + sovStructured(uint64(l))
		}
	}
	if len(m.CompositeColumnIDs) > 0 {
		for _, e := range m.CompositeColumnIDs {
			n += 1 + sovStructured(uint64(e))
		}
	}
	if len(m.StoreColumnIDs) > 0 {
		for _, e := range m.StoreColumnIDs {
			n += 1 + sovStructured(uint64(e))
		}
	}
	l = m.Partitioning.Size()
	n += 1 + l + sovStructured(uint64(l))
	n += 2 + sovStructured(uint64(m.Type))
	n += 3
	n += 2 + sovStructured(uint64(m.Version))
	n += 2 + sovStructured(uint64(m.EncodingType))
	l = m.Sharded.Size()
	n += 2 + l + sovStructured(uint64(l))
	n += 3
	l = m.GeoConfig.Size()
	n += 2 + l + sovStructured(uint64(l))
	l = len(m.Predicate)
	n += 2 + l + sovStructured(uint64(l))
	return n
}

func (m *ConstraintToUpdate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovStructured(uint64(m.ConstraintType))
	l = len(m.Name)
	n += 1 + l + sovStructured(uint64(l))
	l = m.Check.Size()
	n += 1 + l + sovStructured(uint64(l))
	l = m.ForeignKey.Size()
	n += 1 + l + sovStructured(uint64(l))
	n += 1 + sovStructured(uint64(m.NotNullColumn))
	return n
}

func (m *PrimaryKeySwap) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovStructured(uint64(m.NewPrimaryIndexId))
	if len(m.OldIndexes) > 0 {
		for _, e := range m.OldIndexes {
			n += 1 + sovStructured(uint64(e))
		}
	}
	if len(m.NewIndexes) > 0 {
		for _, e := range m.NewIndexes {
			n += 1 + sovStructured(uint64(e))
		}
	}
	n += 1 + sovStructured(uint64(m.OldPrimaryIndexId))
	return n
}

func (m *ComputedColumnSwap) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovStructured(uint64(m.NewColumnId))
	n += 1 + sovStructured(uint64(m.OldColumnId))
	return n
}

func (m *DescriptorMutation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Descriptor_ != nil {
		n += m.Descriptor_.Size()
	}
	n += 1 + sovStructured(uint64(m.State))
	n += 1 + sovStructured(uint64(m.Direction))
	n += 1 + sovStructured(uint64(m.MutationID))
	n += 2
	return n
}

func (m *DescriptorMutation_Column) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Column != nil {
		l = m.Column.Size()
		n += 1 + l + sovStructured(uint64(l))
	}
	return n
}
func (m *DescriptorMutation_Index) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != nil {
		l = m.Index.Size()
		n += 1 + l + sovStructured(uint64(l))
	}
	return n
}
func (m *DescriptorMutation_Constraint) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Constraint != nil {
		l = m.Constraint.Size()
		n += 1 + l + sovStructured(uint64(l))
	}
	return n
}
func (m *DescriptorMutation_PrimaryKeySwap) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PrimaryKeySwap != nil {
		l = m.PrimaryKeySwap.Size()
		n += 1 + l + sovStructured(uint64(l))
	}
	return n
}
func (m *DescriptorMutation_ComputedColumnSwap) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ComputedColumnSwap != nil {
		l = m.ComputedColumnSwap.Size()
		n += 1 + l + sovStructured(uint64(l))
	}
	return n
}
func (m *TableDescriptor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovStructured(uint64(l))
	n += 1 + sovStructured(uint64(m.ID))
	n += 1 + sovStructured(uint64(m.ParentID))
	n += 1 + sovStructured(uint64(m.Version))
	l = m.ModificationTime.Size()
	n += 1 + l + sovStructured(uint64(l))
	if len(m.Columns) > 0 {
		for _, e := range m.Columns {
			l = e.Size()
			n += 1 + l + sovStructured(uint64(l))
		}
	}
	n += 1 + sovStructured(uint64(m.NextColumnID))
	l = m.PrimaryIndex.Size()
	n += 1 + l + sovStructured(uint64(l))
	if len(m.Indexes) > 0 {
		for _, e := range m.Indexes {
			l = e.Size()
			n += 1 + l + sovStructured(uint64(l))
		}
	}
	n += 1 + sovStructured(uint64(m.NextIndexID))
	if m.Privileges != nil {
		l = m.Privileges.Size()
		n += 1 + l + sovStructured(uint64(l))
	}
	if len(m.Mutations) > 0 {
		for _, e := range m.Mutations {
			l = e.Size()
			n += 1 + l + sovStructured(uint64(l))
		}
	}
	if m.Lease != nil {
		l = m.Lease.Size()
		n += 1 + l + sovStructured(uint64(l))
	}
	n += 2 + sovStructured(uint64(m.NextMutationID))
	n += 2 + sovStructured(uint64(m.FormatVersion))
	n += 2 + sovStructured(uint64(m.State))
	if len(m.Checks) > 0 {
		for _, e := range m.Checks {
			l = e.Size()
			n += 2 + l + sovStructured(uint64(l))
		}
	}
	if len(m.DrainingNames) > 0 {
		for _, e := range m.DrainingNames {
			l = e.Size()
			n += 2 + l + sovStructured(uint64(l))
		}
	}
	if len(m.Families) > 0 {
		for _, e := range m.Families {
			l = e.Size()
			n += 2 + l + sovStructured(uint64(l))
		}
	}
	n += 2 + sovStructured(uint64(m.NextFamilyID))
	l = len(m.ViewQuery)
	n += 2 + l + sovStructured(uint64(l))
	if len(m.DependsOn) > 0 {
		for _, e := range m.DependsOn {
			n += 2 + sovStructured(uint64(e))
		}
	}
	if len(m.DependedOnBy) > 0 {
		for _, e := range m.DependedOnBy {
			l = e.Size()
			n += 2 + l + sovStructured(uint64(l))
		}
	}
	if len(m.MutationJobs) > 0 {
		for _, e := range m.MutationJobs {
			l = e.Size()
			n += 2 + l + sovStructured(uint64(l))
		}
	}
	if m.SequenceOpts != nil {
		l = m.SequenceOpts.Size()
		n += 2 + l + sovStructured(uint64(l))
	}
	n += 2 + sovStructured(uint64(m.DropTime))
	l = m.ReplacementOf.Size()
	n += 2 + l + sovStructured(uint64(l))
	n += 2 + sovStructured(uint64(m.AuditMode))
	n += 2 + sovStructured(uint64(m.DropJobID))
	if len(m.GCMutations) > 0 {
		for _, e := range m.GCMutations {
			l = e.Size()
			n += 2 + l + sovStructured(uint64(l))
		}
	}
	l = len(m.CreateQuery)
	n += 2 + l + sovStructured(uint64(l))
	l = m.CreateAsOfTime.Size()
	n += 2 + l + sovStructured(uint64(l))
	if len(m.OutboundFKs) > 0 {
		for _, e := range m.OutboundFKs {
			l = e.Size()
			n += 2 + l + sovStructured(uint64(l))
		}
	}
	if len(m.InboundFKs) > 0 {
		for _, e := range m.InboundFKs {
			l = e.Size()
			n += 2 + l + sovStructured(uint64(l))
		}
	}
	l = len(m.OfflineReason)
	n += 2 + l + sovStructured(uint64(l))
	n += 3
	n += 2 + sovStructured(uint64(m.UnexposedParentSchemaID))
	return n
}

func (m *TableDescriptor_SchemaChangeLease) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovStructured(uint64(m.NodeID))
	n += 1 + sovStructured(uint64(m.ExpirationTime))
	return n
}

func (m *TableDescriptor_CheckConstraint) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Expr)
	n += 1 + l + sovStructured(uint64(l))
	l = len(m.Name)
	n += 1 + l + sovStructured(uint64(l))
	n += 1 + sovStructured(uint64(m.Validity))
	if len(m.ColumnIDs) > 0 {
		for _, e := range m.ColumnIDs {
			n += 1 + sovStructured(uint64(e))
		}
	}
	n += 2
	n += 2
	return n
}

func (m *TableDescriptor_NameInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovStructured(uint64(m.ParentID))
	l = len(m.Name)
	n += 1 + l + sovStructured(uint64(l))
	n += 1 + sovStructured(uint64(m.ParentSchemaID))
	return n
}

func (m *TableDescriptor_Reference) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovStructured(uint64(m.ID))
	n += 1 + sovStructured(uint64(m.IndexID))
	if len(m.ColumnIDs) > 0 {
		for _, e := range m.ColumnIDs {
			n += 1 + sovStructured(uint64(e))
		}
	}
	return n
}

func (m *TableDescriptor_MutationJob) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovStructured(uint64(m.MutationID))
	n += 1 + sovStructured(uint64(m.JobID))
	return n
}

func (m *TableDescriptor_SequenceOpts) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovStructured(uint64(m.Increment))
	n += 1 + sovStructured(uint64(m.MinValue))
	n += 1 + sovStructured(uint64(m.MaxValue))
	n += 1 + sovStructured(uint64(m.Start))
	n += 2
	l = m.SequenceOwner.Size()
	n += 1 + l + sovStructured(uint64(l))
	return n
}

func (m *TableDescriptor_SequenceOpts_SequenceOwner) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovStructured(uint64(m.OwnerColumnID))
	n += 1 + sovStructured(uint64(m.OwnerTableID))
	return n
}

func (m *TableDescriptor_Replacement) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovStructured(uint64(m.ID))
	l = m.Time.Size()
	n += 1 + l + sovStructured(uint64(l))
	return n
}

func (m *TableDescriptor_GCDescriptorMutation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovStructured(uint64(m.IndexID))
	n += 1 + sovStructured(uint64(m.DropTime))
	n += 1 + sovStructured(uint64(m.JobID))
	return n
}

func (m *DatabaseDescriptor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	n += 1 + l + sovStructured(uint64(l))
	n += 1 + sovStructured(uint64(m.ID))
	if m.Privileges != nil {
		l = m.Privileges.Size()
		n += 1 + l + sovStructured(uint64(l))
	}
	return n
}

func (m *TypeDescriptor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovStructured(uint64(m.ParentID))
	n += 1 + sovStructured(uint64(m.ParentSchemaID))
	l = len(m.Name)
	n += 1 + l + sovStructured(uint64(l))
	n += 1 + sovStructured(uint64(m.ID))
	n += 1 + sovStructured(uint64(m.Kind))
	if len(m.EnumMembers) > 0 {
		for _, e := range m.EnumMembers {
			l = e.Size()
			n += 1 + l + sovStructured(uint64(l))
		}
	}
	if m.Alias != nil {
		l = m.Alias.Size()
		n += 1 + l + sovStructured(uint64(l))
	}
	n += 1 + sovStructured(uint64(m.ArrayTypeID))
	return n
}

func (m *TypeDescriptor_EnumMember) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PhysicalRepresentation != nil {
		l = len(m.PhysicalRepresentation)
		n += 1 + l + sovStructured(uint64(l))
	}
	l = len(m.LogicalRepresentation)
	n += 1 + l + sovStructured(uint64(l))
	return n
}

func (m *SchemaDescriptor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovStructured(uint64(m.ParentID))
	l = len(m.Name)
	n += 1 + l + sovStructured(uint64(l))
	n += 1 + sovStructured(uint64(m.ID))
	if m.Privileges != nil {
		l = m.Privileges.Size()
		n += 1 + l + sovStructured(uint64(l))
	}
	return n
}

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

func (m *Descriptor_Table) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Table != nil {
		l = m.Table.Size()
		n += 1 + l + sovStructured(uint64(l))
	}
	return n
}
func (m *Descriptor_Database) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Database != nil {
		l = m.Database.Size()
		n += 1 + l + sovStructured(uint64(l))
	}
	return n
}
func (m *Descriptor_Type) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != nil {
		l = m.Type.Size()
		n += 1 + l + sovStructured(uint64(l))
	}
	return n
}
func (m *Descriptor_Schema) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Schema != nil {
		l = m.Schema.Size()
		n += 1 + l + sovStructured(uint64(l))
	}
	return n
}

func sovStructured(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozStructured(x uint64) (n int) {
	return sovStructured(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ForeignKeyReference) 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 ErrIntOverflowStructured
			}
			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: ForeignKeyReference: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ForeignKeyReference: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Table", wireType)
			}
			m.Table = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Table |= (ID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= (IndexID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				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 ErrInvalidLengthStructured
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Validity", wireType)
			}
			m.Validity = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Validity |= (ConstraintValidity(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SharedPrefixLen", wireType)
			}
			m.SharedPrefixLen = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SharedPrefixLen |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OnDelete", wireType)
			}
			m.OnDelete = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OnDelete |= (ForeignKeyReference_Action(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OnUpdate", wireType)
			}
			m.OnUpdate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OnUpdate |= (ForeignKeyReference_Action(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Match", wireType)
			}
			m.Match = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Match |= (ForeignKeyReference_Match(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStructured(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructured
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ForeignKeyConstraint) 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 ErrIntOverflowStructured
			}
			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: ForeignKeyConstraint: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ForeignKeyConstraint: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OriginTableID", wireType)
			}
			m.OriginTableID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OriginTableID |= (ID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType == 0 {
				var v ColumnID
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (ColumnID(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.OriginColumnIDs = append(m.OriginColumnIDs, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthStructured
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.OriginColumnIDs) == 0 {
					m.OriginColumnIDs = make([]ColumnID, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v ColumnID
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowStructured
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (ColumnID(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.OriginColumnIDs = append(m.OriginColumnIDs, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field OriginColumnIDs", wireType)
			}
		case 3:
			if wireType == 0 {
				var v ColumnID
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (ColumnID(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.ReferencedColumnIDs = append(m.ReferencedColumnIDs, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthStructured
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.ReferencedColumnIDs) == 0 {
					m.ReferencedColumnIDs = make([]ColumnID, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v ColumnID
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowStructured
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (ColumnID(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.ReferencedColumnIDs = append(m.ReferencedColumnIDs, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field ReferencedColumnIDs", wireType)
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReferencedTableID", wireType)
			}
			m.ReferencedTableID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReferencedTableID |= (ID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				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 ErrInvalidLengthStructured
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Validity", wireType)
			}
			m.Validity = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Validity |= (ConstraintValidity(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OnDelete", wireType)
			}
			m.OnDelete = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OnDelete |= (ForeignKeyReference_Action(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OnUpdate", wireType)
			}
			m.OnUpdate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OnUpdate |= (ForeignKeyReference_Action(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Match", wireType)
			}
			m.Match = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Match |= (ForeignKeyReference_Match(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LegacyOriginIndex", wireType)
			}
			m.LegacyOriginIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LegacyOriginIndex |= (IndexID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LegacyReferencedIndex", wireType)
			}
			m.LegacyReferencedIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LegacyReferencedIndex |= (IndexID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStructured(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructured
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ColumnDescriptor) 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 ErrIntOverflowStructured
			}
			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: ColumnDescriptor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ColumnDescriptor: 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 ErrIntOverflowStructured
				}
				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 ErrInvalidLengthStructured
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= (ColumnID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Type == nil {
				m.Type = &types.T{}
			}
			if err := m.Type.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nullable", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Nullable = bool(v != 0)
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultExpr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				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 ErrInvalidLengthStructured
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.DefaultExpr = &s
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hidden", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Hidden = bool(v != 0)
		case 10:
			if wireType == 0 {
				var v ID
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (ID(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.UsesSequenceIds = append(m.UsesSequenceIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthStructured
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.UsesSequenceIds) == 0 {
					m.UsesSequenceIds = make([]ID, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v ID
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowStructured
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (ID(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.UsesSequenceIds = append(m.UsesSequenceIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field UsesSequenceIds", wireType)
			}
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ComputeExpr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				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 ErrInvalidLengthStructured
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.ComputeExpr = &s
			iNdEx = postIndex
		case 12:
			if wireType == 0 {
				var v ID
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (ID(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.OwnsSequenceIds = append(m.OwnsSequenceIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthStructured
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.OwnsSequenceIds) == 0 {
					m.OwnsSequenceIds = make([]ID, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v ID
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowStructured
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (ID(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.OwnsSequenceIds = append(m.OwnsSequenceIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field OwnsSequenceIds", wireType)
			}
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogicalColumnID", wireType)
			}
			m.LogicalColumnID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LogicalColumnID |= (ColumnID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AlterColumnTypeInProgress", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AlterColumnTypeInProgress = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipStructured(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructured
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ColumnFamilyDescriptor) 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 ErrIntOverflowStructured
			}
			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: ColumnFamilyDescriptor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ColumnFamilyDescriptor: 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 ErrIntOverflowStructured
				}
				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 ErrInvalidLengthStructured
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= (FamilyID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ColumnNames", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				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 ErrInvalidLengthStructured
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ColumnNames = append(m.ColumnNames, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType == 0 {
				var v ColumnID
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (ColumnID(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.ColumnIDs = append(m.ColumnIDs, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthStructured
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.ColumnIDs) == 0 {
					m.ColumnIDs = make([]ColumnID, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v ColumnID
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowStructured
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (ColumnID(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.ColumnIDs = append(m.ColumnIDs, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field ColumnIDs", wireType)
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultColumnID", wireType)
			}
			m.DefaultColumnID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DefaultColumnID |= (ColumnID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStructured(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructured
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InterleaveDescriptor_Ancestor) 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 ErrIntOverflowStructured
			}
			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: Ancestor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Ancestor: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableID", wireType)
			}
			m.TableID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TableID |= (ID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IndexID", wireType)
			}
			m.IndexID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IndexID |= (IndexID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SharedPrefixLen", wireType)
			}
			m.SharedPrefixLen = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SharedPrefixLen |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStructured(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructured
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PartitioningDescriptor_List) 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 ErrIntOverflowStructured
			}
			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: List: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: List: 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 ErrIntOverflowStructured
				}
				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 ErrInvalidLengthStructured
			}
			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 Values", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Values = append(m.Values, make([]byte, postIndex-iNdEx))
			copy(m.Values[len(m.Values)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subpartitioning", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Subpartitioning.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStructured(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructured
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PartitioningDescriptor_Range) 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 ErrIntOverflowStructured
			}
			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: Range: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Range: 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 ErrIntOverflowStructured
				}
				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 ErrInvalidLengthStructured
			}
			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 ToExclusive", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ToExclusive = append(m.ToExclusive[:0], dAtA[iNdEx:postIndex]...)
			if m.ToExclusive == nil {
				m.ToExclusive = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FromInclusive", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FromInclusive = append(m.FromInclusive[:0], dAtA[iNdEx:postIndex]...)
			if m.FromInclusive == nil {
				m.FromInclusive = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStructured(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructured
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IndexDescriptor) 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 ErrIntOverflowStructured
			}
			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: IndexDescriptor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IndexDescriptor: 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 ErrIntOverflowStructured
				}
				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 ErrInvalidLengthStructured
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= (IndexID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unique", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Unique = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ColumnNames", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				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 ErrInvalidLengthStructured
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ColumnNames = append(m.ColumnNames, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StoreColumnNames", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				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 ErrInvalidLengthStructured
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StoreColumnNames = append(m.StoreColumnNames, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 6:
			if wireType == 0 {
				var v ColumnID
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (ColumnID(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.ColumnIDs = append(m.ColumnIDs, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthStructured
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.ColumnIDs) == 0 {
					m.ColumnIDs = make([]ColumnID, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v ColumnID
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowStructured
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (ColumnID(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.ColumnIDs = append(m.ColumnIDs, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field ColumnIDs", wireType)
			}
		case 7:
			if wireType == 0 {
				var v ColumnID
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (ColumnID(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.ExtraColumnIDs = append(m.ExtraColumnIDs, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthStructured
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.ExtraColumnIDs) == 0 {
					m.ExtraColumnIDs = make([]ColumnID, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v ColumnID
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowStructured
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (ColumnID(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.ExtraColumnIDs = append(m.ExtraColumnIDs, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field ExtraColumnIDs", wireType)
			}
		case 8:
			if wireType == 0 {
				var v IndexDescriptor_Direction
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (IndexDescriptor_Direction(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.ColumnDirections = append(m.ColumnDirections, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthStructured
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.ColumnDirections) == 0 {
					m.ColumnDirections = make([]IndexDescriptor_Direction, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v IndexDescriptor_Direction
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowStructured
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (IndexDescriptor_Direction(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.ColumnDirections = append(m.ColumnDirections, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field ColumnDirections", wireType)
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ForeignKey", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ForeignKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReferencedBy", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReferencedBy = append(m.ReferencedBy, ForeignKeyReference{})
			if err := m.ReferencedBy[len(m.ReferencedBy)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Interleave", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Interleave.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InterleavedBy", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InterleavedBy = append(m.InterleavedBy, ForeignKeyReference{})
			if err := m.InterleavedBy[len(m.InterleavedBy)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType == 0 {
				var v ColumnID
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (ColumnID(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.CompositeColumnIDs = append(m.CompositeColumnIDs, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthStructured
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.CompositeColumnIDs) == 0 {
					m.CompositeColumnIDs = make([]ColumnID, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v ColumnID
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowStructured
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (ColumnID(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.CompositeColumnIDs = append(m.CompositeColumnIDs, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field CompositeColumnIDs", wireType)
			}
		case 14:
			if wireType == 0 {
				var v ColumnID
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (ColumnID(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.StoreColumnIDs = append(m.StoreColumnIDs, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthStructured
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.StoreColumnIDs) == 0 {
					m.StoreColumnIDs = make([]ColumnID, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v ColumnID
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowStructured
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (ColumnID(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.StoreColumnIDs = append(m.StoreColumnIDs, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field StoreColumnIDs", wireType)
			}
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Partitioning", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Partitioning.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (IndexDescriptor_Type(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 17:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedExplicitly", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CreatedExplicitly = bool(v != 0)
		case 18:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			m.Version = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Version |= (IndexDescriptorVersion(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 19:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EncodingType", wireType)
			}
			m.EncodingType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EncodingType |= (IndexDescriptorEncodingType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sharded", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Sharded.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 21:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Disabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Disabled = bool(v != 0)
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GeoConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GeoConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 23:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Predicate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				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 ErrInvalidLengthStructured
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Predicate = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStructured(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructured
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConstraintToUpdate) Unmarshal(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStructured
			}
			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: ConstraintToUpdate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConstraintToUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConstraintType", wireType)
			}
			m.ConstraintType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ConstraintType |= (ConstraintToUpdate_ConstraintType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				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 ErrInvalidLengthStructured
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000002)
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Check", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Check.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ForeignKey", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ForeignKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotNullColumn", wireType)
			}
			m.NotNullColumn = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NotNullColumn |= (ColumnID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStructured(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructured
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("constraint_type")
	}
	if hasFields[0]&uint64(0x00000002) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("name")
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DescriptorMutation) 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 ErrIntOverflowStructured
			}
			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: DescriptorMutation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DescriptorMutation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Column", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ColumnDescriptor{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Descriptor_ = &DescriptorMutation_Column{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &IndexDescriptor{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Descriptor_ = &DescriptorMutation_Index{v}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= (DescriptorMutation_State(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Direction", wireType)
			}
			m.Direction = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Direction |= (DescriptorMutation_Direction(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MutationID", wireType)
			}
			m.MutationID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MutationID |= (MutationID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rollback", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Rollback = bool(v != 0)
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Constraint", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ConstraintToUpdate{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Descriptor_ = &DescriptorMutation_Constraint{v}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrimaryKeySwap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &PrimaryKeySwap{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Descriptor_ = &DescriptorMutation_PrimaryKeySwap{v}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ComputedColumnSwap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ComputedColumnSwap{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Descriptor_ = &DescriptorMutation_ComputedColumnSwap{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStructured(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructured
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TableDescriptor) 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 ErrIntOverflowStructured
			}
			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: TableDescriptor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TableDescriptor: 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 ErrIntOverflowStructured
				}
				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 ErrInvalidLengthStructured
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= (ID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParentID", wireType)
			}
			m.ParentID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ParentID |= (ID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			m.Version = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Version |= (DescriptorVersion(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ModificationTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ModificationTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Columns", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Columns = append(m.Columns, ColumnDescriptor{})
			if err := m.Columns[len(m.Columns)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextColumnID", wireType)
			}
			m.NextColumnID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NextColumnID |= (ColumnID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrimaryIndex", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PrimaryIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			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 ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Indexes = append(m.Indexes, IndexDescriptor{})
			if err := m.Indexes[len(m.Indexes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextIndexID", wireType)
			}
			m.NextIndexID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NextIndexID |= (IndexID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Privileges", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Privileges == nil {
				m.Privileges = &PrivilegeDescriptor{}
			}
			if err := m.Privileges.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mutations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Mutations = append(m.Mutations, DescriptorMutation{})
			if err := m.Mutations[len(m.Mutations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Lease", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Lease == nil {
				m.Lease = &TableDescriptor_SchemaChangeLease{}
			}
			if err := m.Lease.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextMutationID", wireType)
			}
			m.NextMutationID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NextMutationID |= (MutationID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 17:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FormatVersion", wireType)
			}
			m.FormatVersion = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FormatVersion |= (FormatVersion(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 19:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= (TableDescriptor_State(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Checks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Checks = append(m.Checks, &TableDescriptor_CheckConstraint{})
			if err := m.Checks[len(m.Checks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DrainingNames", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DrainingNames = append(m.DrainingNames, TableDescriptor_NameInfo{})
			if err := m.DrainingNames[len(m.DrainingNames)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Families", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Families = append(m.Families, ColumnFamilyDescriptor{})
			if err := m.Families[len(m.Families)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 23:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextFamilyID", wireType)
			}
			m.NextFamilyID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NextFamilyID |= (FamilyID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ViewQuery", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				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 ErrInvalidLengthStructured
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ViewQuery = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 25:
			if wireType == 0 {
				var v ID
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (ID(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.DependsOn = append(m.DependsOn, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthStructured
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.DependsOn) == 0 {
					m.DependsOn = make([]ID, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v ID
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowStructured
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (ID(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.DependsOn = append(m.DependsOn, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field DependsOn", wireType)
			}
		case 26:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DependedOnBy", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DependedOnBy = append(m.DependedOnBy, TableDescriptor_Reference{})
			if err := m.DependedOnBy[len(m.DependedOnBy)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 27:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MutationJobs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MutationJobs = append(m.MutationJobs, TableDescriptor_MutationJob{})
			if err := m.MutationJobs[len(m.MutationJobs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 28:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SequenceOpts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SequenceOpts == nil {
				m.SequenceOpts = &TableDescriptor_SequenceOpts{}
			}
			if err := m.SequenceOpts.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 29:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DropTime", wireType)
			}
			m.DropTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DropTime |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 30:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReplacementOf", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ReplacementOf.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 31:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AuditMode", wireType)
			}
			m.AuditMode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AuditMode |= (TableDescriptor_AuditMode(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 32:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DropJobID", wireType)
			}
			m.DropJobID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DropJobID |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 33:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GCMutations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GCMutations = append(m.GCMutations, TableDescriptor_GCDescriptorMutation{})
			if err := m.GCMutations[len(m.GCMutations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 34:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateQuery", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				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 ErrInvalidLengthStructured
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CreateQuery = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 35:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateAsOfTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CreateAsOfTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 36:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutboundFKs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OutboundFKs = append(m.OutboundFKs, ForeignKeyConstraint{})
			if err := m.OutboundFKs[len(m.OutboundFKs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 37:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InboundFKs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InboundFKs = append(m.InboundFKs, ForeignKeyConstraint{})
			if err := m.InboundFKs[len(m.InboundFKs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 38:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OfflineReason", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				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 ErrInvalidLengthStructured
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OfflineReason = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 39:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Temporary", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Temporary = bool(v != 0)
		case 40:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnexposedParentSchemaID", wireType)
			}
			m.UnexposedParentSchemaID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UnexposedParentSchemaID |= (ID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStructured(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructured
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TableDescriptor_SchemaChangeLease) 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 ErrIntOverflowStructured
			}
			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: SchemaChangeLease: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SchemaChangeLease: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeID", wireType)
			}
			m.NodeID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NodeID |= (github_com_cockroachdb_cockroach_pkg_roachpb.NodeID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpirationTime", wireType)
			}
			m.ExpirationTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExpirationTime |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStructured(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructured
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TableDescriptor_CheckConstraint) 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 ErrIntOverflowStructured
			}
			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: CheckConstraint: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CheckConstraint: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Expr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				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 ErrInvalidLengthStructured
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Expr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				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 ErrInvalidLengthStructured
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Validity", wireType)
			}
			m.Validity = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Validity |= (ConstraintValidity(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType == 0 {
				var v ColumnID
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (ColumnID(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.ColumnIDs = append(m.ColumnIDs, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowStructured
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthStructured
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.ColumnIDs) == 0 {
					m.ColumnIDs = make([]ColumnID, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v ColumnID
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowStructured
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (ColumnID(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.ColumnIDs = append(m.ColumnIDs, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field ColumnIDs", wireType)
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsNonNullConstraint", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsNonNullConstraint = bool(v != 0)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hidden", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Hidden = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipStructured(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructured
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TableDescriptor_SequenceOpts) 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 ErrIntOverflowStructured
			}
			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: SequenceOpts: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SequenceOpts: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Increment", wireType)
			}
			m.Increment = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Increment |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinValue", wireType)
			}
			m.MinValue = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinValue |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxValue", wireType)
			}
			m.MaxValue = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxValue |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
			}
			m.Start = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Start |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Virtual", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Virtual = bool(v != 0)
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SequenceOwner", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SequenceOwner.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStructured(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructured
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TableDescriptor_SequenceOpts_SequenceOwner) 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 ErrIntOverflowStructured
			}
			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: SequenceOwner: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SequenceOwner: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OwnerColumnID", wireType)
			}
			m.OwnerColumnID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OwnerColumnID |= (ColumnID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OwnerTableID", wireType)
			}
			m.OwnerTableID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OwnerTableID |= (ID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStructured(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructured
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TableDescriptor_GCDescriptorMutation) 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 ErrIntOverflowStructured
			}
			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: GCDescriptorMutation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GCDescriptorMutation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IndexID", wireType)
			}
			m.IndexID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IndexID |= (IndexID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DropTime", wireType)
			}
			m.DropTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DropTime |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field JobID", wireType)
			}
			m.JobID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.JobID |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStructured(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructured
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DatabaseDescriptor) 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 ErrIntOverflowStructured
			}
			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: DatabaseDescriptor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DatabaseDescriptor: 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 ErrIntOverflowStructured
				}
				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 ErrInvalidLengthStructured
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= (ID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Privileges", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Privileges == nil {
				m.Privileges = &PrivilegeDescriptor{}
			}
			if err := m.Privileges.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStructured(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructured
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TypeDescriptor) 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 ErrIntOverflowStructured
			}
			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: TypeDescriptor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TypeDescriptor: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParentID", wireType)
			}
			m.ParentID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ParentID |= (ID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParentSchemaID", wireType)
			}
			m.ParentSchemaID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ParentSchemaID |= (ID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				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 ErrInvalidLengthStructured
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= (ID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
			}
			m.Kind = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Kind |= (TypeDescriptor_Kind(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnumMembers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EnumMembers = append(m.EnumMembers, TypeDescriptor_EnumMember{})
			if err := m.EnumMembers[len(m.EnumMembers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Alias", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Alias == nil {
				m.Alias = &types.T{}
			}
			if err := m.Alias.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ArrayTypeID", wireType)
			}
			m.ArrayTypeID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ArrayTypeID |= (ID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStructured(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructured
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Descriptor) 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 ErrIntOverflowStructured
			}
			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: Descriptor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Descriptor: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Table", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &TableDescriptor{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Union = &Descriptor_Table{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Database", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &DatabaseDescriptor{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Union = &Descriptor_Database{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &TypeDescriptor{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Union = &Descriptor_Type{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Schema", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStructured
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStructured
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &SchemaDescriptor{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Union = &Descriptor_Schema{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStructured(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthStructured
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipStructured(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, ErrIntOverflowStructured
			}
			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, ErrIntOverflowStructured
				}
				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, ErrIntOverflowStructured
				}
				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, ErrInvalidLengthStructured
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowStructured
					}
					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 := skipStructured(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 (
	ErrInvalidLengthStructured = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowStructured   = fmt.Errorf("proto: integer overflow")
)

func init() {
	proto.RegisterFile("sql/sqlbase/structured.proto", fileDescriptor_structured_6e223c312147c376)
}

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