github.com/cockroachdb/cockroachdb-parser@v0.23.3-0.20240213214944-911057d40c9a/pkg/sql/sessiondatapb/session_data.pb.go

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

package sessiondatapb

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	github_com_cockroachdb_cockroach_pkg_security_username "github.com/cockroachdb/cockroachdb-parser/pkg/security/username"
	lex "github.com/cockroachdb/cockroachdb-parser/pkg/sql/lex"
	duration "github.com/cockroachdb/cockroachdb-parser/pkg/util/duration"
	pgdate "github.com/cockroachdb/cockroachdb-parser/pkg/util/timeutil/pgdate"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	_ "github.com/gogo/protobuf/types"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	io "io"
	math "math"
	math_bits "math/bits"
	time "time"
)

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

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// VectorizeExecMode controls if an when the Executor executes queries using
// the columnar execution engine.
type VectorizeExecMode int32

const (
	// VectorizeUnset means the VectorizeExecMode wasn't explicitly set. Having
	// the first enum value as zero is required by proto3. This is mapped to
	// VectorizeOn.
	VectorizeUnset VectorizeExecMode = 0
	// VectorizeOn means that any supported queries will be run using the
	// columnar execution.
	VectorizeOn VectorizeExecMode = 2
	// VectorizeExperimentalAlways means that we attempt to vectorize all
	// queries; unsupported queries will fail. Mostly used for testing.
	VectorizeExperimentalAlways VectorizeExecMode = 3
	// VectorizeOff means that columnar execution is disabled.
	VectorizeOff VectorizeExecMode = 4
)

var VectorizeExecMode_name = map[int32]string{
	0: "unset",
	2: "on",
	3: "experimental_always",
	4: "off",
}

var VectorizeExecMode_value = map[string]int32{
	"unset":               0,
	"on":                  2,
	"experimental_always": 3,
	"off":                 4,
}

func (VectorizeExecMode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_9fa1c5a4e61eec38, []int{0}
}

// SessionData contains session parameters that are easily serializable and are
// required to be propagated to the remote nodes for the correct execution of
// DistSQL flows.
type SessionData struct {
	// Database indicates the "current" database for the purpose of resolving
	// names.
	Database string `protobuf:"bytes,1,opt,name=database,proto3" json:"database,omitempty"`
	// ApplicationName is the name of the application running the current
	// session. This can be used for logging and per-application statistics.
	ApplicationName string `protobuf:"bytes,2,opt,name=application_name,json=applicationName,proto3" json:"application_name,omitempty"`
	// User is the name of the user logged into the session.
	UserProto github_com_cockroachdb_cockroach_pkg_security_username.SQLUsernameProto `protobuf:"bytes,3,opt,name=user_proto,json=userProto,proto3,casttype=github.com/cockroachdb/cockroachdb-parser/pkg/security/username.SQLUsernameProto" json:"user_proto,omitempty"`
	// DataConversion gives access to the data conversion configuration.
	DataConversionConfig DataConversionConfig `protobuf:"bytes,4,opt,name=data_conversion_config,json=dataConversionConfig,proto3" json:"data_conversion_config"`
	// VectorizeMode indicates which kinds of queries to use vectorized execution
	// engine for.
	VectorizeMode VectorizeExecMode `protobuf:"varint,5,opt,name=vectorize_mode,json=vectorizeMode,proto3,enum=cockroach.sql.sessiondatapb.VectorizeExecMode" json:"vectorize_mode,omitempty"`
	// TestingVectorizeInjectPanics indicates whether random panics are injected
	// into the vectorized flow execution. The goal of such behavior is making
	// sure that errors that are propagated as panics in the vectorized engine
	// are caught in all scenarios.
	TestingVectorizeInjectPanics bool `protobuf:"varint,6,opt,name=testing_vectorize_inject_panics,json=testingVectorizeInjectPanics,proto3" json:"testing_vectorize_inject_panics,omitempty"`
	// DefaultIntSize specifies the size in bits or bytes (preferred) of how a
	// "naked" INT type should be parsed.
	DefaultIntSize int32 `protobuf:"varint,7,opt,name=default_int_size,json=defaultIntSize,proto3" json:"default_int_size,omitempty"`
	// The name of the location according to whose current timezone we're going to
	// parse timestamps. Used to initialize sessiondata.SessionData.Location on
	// the remote nodes.
	//
	// Note that the current serialization of the time.Location objects as
	// strings has many drawbacks which could lead to unstable computation on the
	// remote nodes. See #36864 and
	// https://github.com/cockroachdb/cockroachdb-parser/pull/55377#issuecomment-707794695
	// for more details.
	Location string `protobuf:"bytes,8,opt,name=location,proto3" json:"location,omitempty"`
	// SearchPath is a list of namespaces to search builtins in. Used to
	// initialize sessiondata.SessionData.SearchPath on the remote nodes.
	SearchPath          []string `protobuf:"bytes,9,rep,name=search_path,json=searchPath,proto3" json:"search_path,omitempty"`
	TemporarySchemaName string   `protobuf:"bytes,10,opt,name=temporary_schema_name,json=temporarySchemaName,proto3" json:"temporary_schema_name,omitempty"`
	// SeqState gives access to the SQL sequences that have been manipulated by
	// the session.
	SeqState SequenceState `protobuf:"bytes,11,opt,name=seq_state,json=seqState,proto3" json:"seq_state"`
	// WorkMemLimit determines how much RAM (in bytes) a single operation of a
	// single query can use before it has to spill to disk.
	WorkMemLimit int64 `protobuf:"varint,12,opt,name=WorkMemLimit,proto3" json:"WorkMemLimit,omitempty"`
	// LockTimeout is the maximum amount of time that a query will wait while
	// attempting to acquire a lock on a key or while blocking on an existing
	// lock in order to perform a non-locking read on a key.
	LockTimeout time.Duration `protobuf:"bytes,15,opt,name=lock_timeout,json=lockTimeout,proto3,stdduration" json:"lock_timeout"`
	// Internal is true if this query came from InternalExecutor or an internal
	// planner.
	Internal bool `protobuf:"varint,16,opt,name=internal,proto3" json:"internal,omitempty"`
	// OnUpdateRehomeRowEnabled controls whether the ON UPDATE rehome_row()
	// will actually trigger on row updates.
	OnUpdateRehomeRowEnabled bool `protobuf:"varint,17,opt,name=on_update_rehome_row_enabled,json=onUpdateRehomeRowEnabled,proto3" json:"on_update_rehome_row_enabled,omitempty"`
	// JoinReaderOrderingStrategyBatchSize is the size limit on the input rows to
	// the joinReader processor (when ordering is required to be maintained) to
	// construct a single lookup KV batch.
	JoinReaderOrderingStrategyBatchSize int64 `protobuf:"varint,18,opt,name=join_reader_ordering_strategy_batch_size,json=joinReaderOrderingStrategyBatchSize,proto3" json:"join_reader_ordering_strategy_batch_size,omitempty"`
	// ParallelizeMultiKeyLookupJoinsEnabled is true when the join reader should
	// parallelize lookup batches under all circumstances. Enabling this will
	// increase the speed of lookup joins when each input row might get multiple
	// looked up rows at the cost of increased memory usage.
	ParallelizeMultiKeyLookupJoinsEnabled bool `protobuf:"varint,19,opt,name=parallelize_multi_key_lookup_joins_enabled,json=parallelizeMultiKeyLookupJoinsEnabled,proto3" json:"parallelize_multi_key_lookup_joins_enabled,omitempty"`
	// TrigramSimilarityThreshold configures the value that's used to compare
	// trigram similarities to in order to evaluate the string % string overload.
	TrigramSimilarityThreshold float64 `protobuf:"fixed64,20,opt,name=trigram_similarity_threshold,json=trigramSimilarityThreshold,proto3" json:"trigram_similarity_threshold,omitempty"`
	// Troubleshooting mode determines whether we refuse to do additional work
	// with the query (i.e. collect & emit telemetry data). Troubleshooting mode
	// is disabled by default.
	TroubleshootingMode bool `protobuf:"varint,21,opt,name=troubleshooting_mode,json=troubleshootingMode,proto3" json:"troubleshooting_mode,omitempty"`
	// JoinReaderNoOrderingStrategyBatchSize is the size limit on the input rows
	// to the joinReader processor (when ordering is **not** required to be
	// maintained) to construct a single lookup KV batch.
	JoinReaderNoOrderingStrategyBatchSize int64 `protobuf:"varint,22,opt,name=join_reader_no_ordering_strategy_batch_size,json=joinReaderNoOrderingStrategyBatchSize,proto3" json:"join_reader_no_ordering_strategy_batch_size,omitempty"`
	// JoinReaderIndexJoinStrategyBatchSize is the size limit on the input rows
	// to the joinReader processor (when performing index joins) to construct a
	// single lookup KV batch.
	JoinReaderIndexJoinStrategyBatchSize int64 `protobuf:"varint,23,opt,name=join_reader_index_join_strategy_batch_size,json=joinReaderIndexJoinStrategyBatchSize,proto3" json:"join_reader_index_join_strategy_batch_size,omitempty"`
	// IndexJoinStreamerBatchSize is the size limit on the input rows to the
	// ColIndexJoin operator (when it is using the Streamer API) to construct a
	// single lookup KV batch.
	IndexJoinStreamerBatchSize int64 `protobuf:"varint,24,opt,name=index_join_streamer_batch_size,json=indexJoinStreamerBatchSize,proto3" json:"index_join_streamer_batch_size,omitempty"`
	// DirectColumnarScansEnabled indicates whether the COL_BATCH_RESPONSE scan
	// format should be used for ScanRequests and ReverseScanRequests whenever
	// possible.
	DirectColumnarScansEnabled bool `protobuf:"varint,25,opt,name=direct_columnar_scans_enabled,json=directColumnarScansEnabled,proto3" json:"direct_columnar_scans_enabled,omitempty"`
	// DefaultTextSearchConfig configures the default text search configuration
	// that is used for builtins like to_tsvector and to_tsquery if no
	// text search configuration is explicitly passed in.
	DefaultTextSearchConfig string `protobuf:"bytes,26,opt,name=default_text_search_config,json=defaultTextSearchConfig,proto3" json:"default_text_search_config,omitempty"`
	// StreamerAlwaysMaintainOrdering indicates that the SQL users of the Streamer
	// should always ask it to maintain the ordering, even when it might not be
	// strictly necessary for the query.
	//
	// This session variable is introduced as a possible workaround in case we
	// have more bugs like #113013.
	StreamerAlwaysMaintainOrdering bool `protobuf:"varint,27,opt,name=streamer_always_maintain_ordering,json=streamerAlwaysMaintainOrdering,proto3" json:"streamer_always_maintain_ordering,omitempty"`
	// StreamerInOrderEagerMemoryUsageFraction controls the fraction of the
	// streamer's memory budget that might be used for issuing requests eagerly,
	// in the InOrder mode.
	StreamerInOrderEagerMemoryUsageFraction float64 `protobuf:"fixed64,28,opt,name=streamer_in_order_eager_memory_usage_fraction,json=streamerInOrderEagerMemoryUsageFraction,proto3" json:"streamer_in_order_eager_memory_usage_fraction,omitempty"`
	// StreamerOutOfOrderEagerMemoryUsageFraction controls the fraction of the
	// streamer's memory budget that might be used for issuing requests eagerly,
	// in the OutOfOrder mode.
	StreamerOutOfOrderEagerMemoryUsageFraction float64 `protobuf:"fixed64,29,opt,name=streamer_out_of_order_eager_memory_usage_fraction,json=streamerOutOfOrderEagerMemoryUsageFraction,proto3" json:"streamer_out_of_order_eager_memory_usage_fraction,omitempty"`
	// StreamerHeadOfLineOnlyFraction controls the fraction of the available
	// streamer's memory budget that will be used to set the TargetBytes limit on
	// head-of-the-line request in case the "eager" memory usage limit has been
	// exceeded.
	StreamerHeadOfLineOnlyFraction float64 `protobuf:"fixed64,30,opt,name=streamer_head_of_line_only_fraction,json=streamerHeadOfLineOnlyFraction,proto3" json:"streamer_head_of_line_only_fraction,omitempty"`
	// DistSQLPlanGatewayBias controls the factor of times more partition spans
	// the gateway node is allowed to be assigned in the absence of a better
	// choice relative to the distribution of partition spans on other eligible
	// instances. Refer to `shouldPickGateway` for more details.
	//
	// This field is in SessionData because that is the format in which a job
	// serializes and stores session variables at the time of job creation. A job
	// could be adopted by any node in the cluster (not necessarily the gateway)
	// and so we will need this information available on all nodes.
	DistsqlPlanGatewayBias int64 `protobuf:"varint,31,opt,name=distsql_plan_gateway_bias,json=distsqlPlanGatewayBias,proto3" json:"distsql_plan_gateway_bias,omitempty"`
}

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

var xxx_messageInfo_SessionData proto.InternalMessageInfo

// DataConversionConfig contains the parameters that influence the output
// of certain data types as strings or bytes.
type DataConversionConfig struct {
	// BytesEncodeFormat indicates how to encode byte arrays when converting to
	// string.
	BytesEncodeFormat lex.BytesEncodeFormat `protobuf:"varint,1,opt,name=bytes_encode_format,json=bytesEncodeFormat,proto3,enum=cockroach.sql.sessiondatapb.BytesEncodeFormat" json:"bytes_encode_format,omitempty"`
	// ExtraFloatDigits indicates the number of digits beyond the standard number
	// to use for float conversions.This must be set to a value between -15 and
	// 3, inclusive.
	ExtraFloatDigits int32 `protobuf:"varint,2,opt,name=extra_float_digits,json=extraFloatDigits,proto3" json:"extra_float_digits,omitempty"`
	// IntervalStyle indicates the style to parse and display intervals as.
	IntervalStyle duration.IntervalStyle `protobuf:"varint,3,opt,name=interval_style,json=intervalStyle,proto3,enum=cockroach.util.duration.IntervalStyle" json:"interval_style,omitempty"`
	// DateStyle indicates the style to parse and display dates as.
	DateStyle pgdate.DateStyle `protobuf:"bytes,4,opt,name=date_style,json=dateStyle,proto3" json:"date_style"`
}

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

var xxx_messageInfo_DataConversionConfig proto.InternalMessageInfo

// SequenceState is used to marshall the sessiondata.SequenceState struct.
type SequenceState struct {
	Seqs []*SequenceState_Seq `protobuf:"bytes,1,rep,name=seqs,proto3" json:"seqs,omitempty"`
	// last_seq_incremented is the id of the last sequence incremented by the
	// session. This field is filled in iff seqs is not empty.
	LastSeqIncremented uint32 `protobuf:"varint,2,opt,name=last_seq_incremented,json=lastSeqIncremented,proto3" json:"last_seq_incremented,omitempty"`
}

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

var xxx_messageInfo_SequenceState proto.InternalMessageInfo

// Seq represents the last value of one sequence modified by the session.
type SequenceState_Seq struct {
	SeqID     uint32 `protobuf:"varint,1,opt,name=seq_id,json=seqId,proto3" json:"seq_id,omitempty"`
	LatestVal int64  `protobuf:"varint,2,opt,name=latest_val,json=latestVal,proto3" json:"latest_val,omitempty"`
}

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

var xxx_messageInfo_SequenceState_Seq proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("cockroach.parser.sql.sessiondatapb.VectorizeExecMode", VectorizeExecMode_name, VectorizeExecMode_value)
	proto.RegisterType((*SessionData)(nil), "cockroach.parser.sql.sessiondatapb.SessionData")
	proto.RegisterType((*DataConversionConfig)(nil), "cockroach.parser.sql.sessiondatapb.DataConversionConfig")
	proto.RegisterType((*SequenceState)(nil), "cockroach.parser.sql.sessiondatapb.SequenceState")
	proto.RegisterType((*SequenceState_Seq)(nil), "cockroach.parser.sql.sessiondatapb.SequenceState.Seq")
}

func init() {
	proto.RegisterFile("sql/sessiondatapb/session_data.proto", fileDescriptor_9fa1c5a4e61eec38)
}

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

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

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

func (m *SessionData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DistsqlPlanGatewayBias != 0 {
		i = encodeVarintSessionData(dAtA, i, uint64(m.DistsqlPlanGatewayBias))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xf8
	}
	if m.StreamerHeadOfLineOnlyFraction != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.StreamerHeadOfLineOnlyFraction))))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xf1
	}
	if m.StreamerOutOfOrderEagerMemoryUsageFraction != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.StreamerOutOfOrderEagerMemoryUsageFraction))))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xe9
	}
	if m.StreamerInOrderEagerMemoryUsageFraction != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.StreamerInOrderEagerMemoryUsageFraction))))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xe1
	}
	if m.StreamerAlwaysMaintainOrdering {
		i--
		if m.StreamerAlwaysMaintainOrdering {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xd8
	}
	if len(m.DefaultTextSearchConfig) > 0 {
		i -= len(m.DefaultTextSearchConfig)
		copy(dAtA[i:], m.DefaultTextSearchConfig)
		i = encodeVarintSessionData(dAtA, i, uint64(len(m.DefaultTextSearchConfig)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xd2
	}
	if m.DirectColumnarScansEnabled {
		i--
		if m.DirectColumnarScansEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xc8
	}
	if m.IndexJoinStreamerBatchSize != 0 {
		i = encodeVarintSessionData(dAtA, i, uint64(m.IndexJoinStreamerBatchSize))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xc0
	}
	if m.JoinReaderIndexJoinStrategyBatchSize != 0 {
		i = encodeVarintSessionData(dAtA, i, uint64(m.JoinReaderIndexJoinStrategyBatchSize))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xb8
	}
	if m.JoinReaderNoOrderingStrategyBatchSize != 0 {
		i = encodeVarintSessionData(dAtA, i, uint64(m.JoinReaderNoOrderingStrategyBatchSize))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xb0
	}
	if m.TroubleshootingMode {
		i--
		if m.TroubleshootingMode {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa8
	}
	if m.TrigramSimilarityThreshold != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.TrigramSimilarityThreshold))))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa1
	}
	if m.ParallelizeMultiKeyLookupJoinsEnabled {
		i--
		if m.ParallelizeMultiKeyLookupJoinsEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x98
	}
	if m.JoinReaderOrderingStrategyBatchSize != 0 {
		i = encodeVarintSessionData(dAtA, i, uint64(m.JoinReaderOrderingStrategyBatchSize))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x90
	}
	if m.OnUpdateRehomeRowEnabled {
		i--
		if m.OnUpdateRehomeRowEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x88
	}
	if m.Internal {
		i--
		if m.Internal {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x80
	}
	n1, err1 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.LockTimeout, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.LockTimeout):])
	if err1 != nil {
		return 0, err1
	}
	i -= n1
	i = encodeVarintSessionData(dAtA, i, uint64(n1))
	i--
	dAtA[i] = 0x7a
	if m.WorkMemLimit != 0 {
		i = encodeVarintSessionData(dAtA, i, uint64(m.WorkMemLimit))
		i--
		dAtA[i] = 0x60
	}
	{
		size, err := m.SeqState.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintSessionData(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x5a
	if len(m.TemporarySchemaName) > 0 {
		i -= len(m.TemporarySchemaName)
		copy(dAtA[i:], m.TemporarySchemaName)
		i = encodeVarintSessionData(dAtA, i, uint64(len(m.TemporarySchemaName)))
		i--
		dAtA[i] = 0x52
	}
	if len(m.SearchPath) > 0 {
		for iNdEx := len(m.SearchPath) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SearchPath[iNdEx])
			copy(dAtA[i:], m.SearchPath[iNdEx])
			i = encodeVarintSessionData(dAtA, i, uint64(len(m.SearchPath[iNdEx])))
			i--
			dAtA[i] = 0x4a
		}
	}
	if len(m.Location) > 0 {
		i -= len(m.Location)
		copy(dAtA[i:], m.Location)
		i = encodeVarintSessionData(dAtA, i, uint64(len(m.Location)))
		i--
		dAtA[i] = 0x42
	}
	if m.DefaultIntSize != 0 {
		i = encodeVarintSessionData(dAtA, i, uint64(m.DefaultIntSize))
		i--
		dAtA[i] = 0x38
	}
	if m.TestingVectorizeInjectPanics {
		i--
		if m.TestingVectorizeInjectPanics {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.VectorizeMode != 0 {
		i = encodeVarintSessionData(dAtA, i, uint64(m.VectorizeMode))
		i--
		dAtA[i] = 0x28
	}
	{
		size, err := m.DataConversionConfig.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintSessionData(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.UserProto) > 0 {
		i -= len(m.UserProto)
		copy(dAtA[i:], m.UserProto)
		i = encodeVarintSessionData(dAtA, i, uint64(len(m.UserProto)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ApplicationName) > 0 {
		i -= len(m.ApplicationName)
		copy(dAtA[i:], m.ApplicationName)
		i = encodeVarintSessionData(dAtA, i, uint64(len(m.ApplicationName)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Database) > 0 {
		i -= len(m.Database)
		copy(dAtA[i:], m.Database)
		i = encodeVarintSessionData(dAtA, i, uint64(len(m.Database)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *DataConversionConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.DateStyle.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintSessionData(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.IntervalStyle != 0 {
		i = encodeVarintSessionData(dAtA, i, uint64(m.IntervalStyle))
		i--
		dAtA[i] = 0x18
	}
	if m.ExtraFloatDigits != 0 {
		i = encodeVarintSessionData(dAtA, i, uint64(m.ExtraFloatDigits))
		i--
		dAtA[i] = 0x10
	}
	if m.BytesEncodeFormat != 0 {
		i = encodeVarintSessionData(dAtA, i, uint64(m.BytesEncodeFormat))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SequenceState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LastSeqIncremented != 0 {
		i = encodeVarintSessionData(dAtA, i, uint64(m.LastSeqIncremented))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Seqs) > 0 {
		for iNdEx := len(m.Seqs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Seqs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSessionData(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *SequenceState_Seq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LatestVal != 0 {
		i = encodeVarintSessionData(dAtA, i, uint64(m.LatestVal))
		i--
		dAtA[i] = 0x10
	}
	if m.SeqID != 0 {
		i = encodeVarintSessionData(dAtA, i, uint64(m.SeqID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintSessionData(dAtA []byte, offset int, v uint64) int {
	offset -= sovSessionData(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *SessionData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Database)
	if l > 0 {
		n += 1 + l + sovSessionData(uint64(l))
	}
	l = len(m.ApplicationName)
	if l > 0 {
		n += 1 + l + sovSessionData(uint64(l))
	}
	l = len(m.UserProto)
	if l > 0 {
		n += 1 + l + sovSessionData(uint64(l))
	}
	l = m.DataConversionConfig.Size()
	n += 1 + l + sovSessionData(uint64(l))
	if m.VectorizeMode != 0 {
		n += 1 + sovSessionData(uint64(m.VectorizeMode))
	}
	if m.TestingVectorizeInjectPanics {
		n += 2
	}
	if m.DefaultIntSize != 0 {
		n += 1 + sovSessionData(uint64(m.DefaultIntSize))
	}
	l = len(m.Location)
	if l > 0 {
		n += 1 + l + sovSessionData(uint64(l))
	}
	if len(m.SearchPath) > 0 {
		for _, s := range m.SearchPath {
			l = len(s)
			n += 1 + l + sovSessionData(uint64(l))
		}
	}
	l = len(m.TemporarySchemaName)
	if l > 0 {
		n += 1 + l + sovSessionData(uint64(l))
	}
	l = m.SeqState.Size()
	n += 1 + l + sovSessionData(uint64(l))
	if m.WorkMemLimit != 0 {
		n += 1 + sovSessionData(uint64(m.WorkMemLimit))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.LockTimeout)
	n += 1 + l + sovSessionData(uint64(l))
	if m.Internal {
		n += 3
	}
	if m.OnUpdateRehomeRowEnabled {
		n += 3
	}
	if m.JoinReaderOrderingStrategyBatchSize != 0 {
		n += 2 + sovSessionData(uint64(m.JoinReaderOrderingStrategyBatchSize))
	}
	if m.ParallelizeMultiKeyLookupJoinsEnabled {
		n += 3
	}
	if m.TrigramSimilarityThreshold != 0 {
		n += 10
	}
	if m.TroubleshootingMode {
		n += 3
	}
	if m.JoinReaderNoOrderingStrategyBatchSize != 0 {
		n += 2 + sovSessionData(uint64(m.JoinReaderNoOrderingStrategyBatchSize))
	}
	if m.JoinReaderIndexJoinStrategyBatchSize != 0 {
		n += 2 + sovSessionData(uint64(m.JoinReaderIndexJoinStrategyBatchSize))
	}
	if m.IndexJoinStreamerBatchSize != 0 {
		n += 2 + sovSessionData(uint64(m.IndexJoinStreamerBatchSize))
	}
	if m.DirectColumnarScansEnabled {
		n += 3
	}
	l = len(m.DefaultTextSearchConfig)
	if l > 0 {
		n += 2 + l + sovSessionData(uint64(l))
	}
	if m.StreamerAlwaysMaintainOrdering {
		n += 3
	}
	if m.StreamerInOrderEagerMemoryUsageFraction != 0 {
		n += 10
	}
	if m.StreamerOutOfOrderEagerMemoryUsageFraction != 0 {
		n += 10
	}
	if m.StreamerHeadOfLineOnlyFraction != 0 {
		n += 10
	}
	if m.DistsqlPlanGatewayBias != 0 {
		n += 2 + sovSessionData(uint64(m.DistsqlPlanGatewayBias))
	}
	return n
}

func (m *DataConversionConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BytesEncodeFormat != 0 {
		n += 1 + sovSessionData(uint64(m.BytesEncodeFormat))
	}
	if m.ExtraFloatDigits != 0 {
		n += 1 + sovSessionData(uint64(m.ExtraFloatDigits))
	}
	if m.IntervalStyle != 0 {
		n += 1 + sovSessionData(uint64(m.IntervalStyle))
	}
	l = m.DateStyle.Size()
	n += 1 + l + sovSessionData(uint64(l))
	return n
}

func (m *SequenceState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Seqs) > 0 {
		for _, e := range m.Seqs {
			l = e.Size()
			n += 1 + l + sovSessionData(uint64(l))
		}
	}
	if m.LastSeqIncremented != 0 {
		n += 1 + sovSessionData(uint64(m.LastSeqIncremented))
	}
	return n
}

func (m *SequenceState_Seq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SeqID != 0 {
		n += 1 + sovSessionData(uint64(m.SeqID))
	}
	if m.LatestVal != 0 {
		n += 1 + sovSessionData(uint64(m.LatestVal))
	}
	return n
}

func sovSessionData(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozSessionData(x uint64) (n int) {
	return sovSessionData(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *SessionData) 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 ErrIntOverflowSessionData
			}
			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: SessionData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SessionData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Database", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				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 ErrInvalidLengthSessionData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSessionData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Database = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApplicationName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				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 ErrInvalidLengthSessionData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSessionData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ApplicationName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserProto", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				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 ErrInvalidLengthSessionData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSessionData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UserProto = github_com_cockroachdb_cockroach_pkg_security_username.SQLUsernameProto(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataConversionConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSessionData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSessionData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DataConversionConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VectorizeMode", wireType)
			}
			m.VectorizeMode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VectorizeMode |= VectorizeExecMode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TestingVectorizeInjectPanics", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.TestingVectorizeInjectPanics = bool(v != 0)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultIntSize", wireType)
			}
			m.DefaultIntSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DefaultIntSize |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Location", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				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 ErrInvalidLengthSessionData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSessionData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Location = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SearchPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				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 ErrInvalidLengthSessionData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSessionData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SearchPath = append(m.SearchPath, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TemporarySchemaName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				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 ErrInvalidLengthSessionData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSessionData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TemporarySchemaName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SeqState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSessionData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSessionData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SeqState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WorkMemLimit", wireType)
			}
			m.WorkMemLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WorkMemLimit |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LockTimeout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSessionData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSessionData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.LockTimeout, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Internal", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Internal = bool(v != 0)
		case 17:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OnUpdateRehomeRowEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OnUpdateRehomeRowEnabled = bool(v != 0)
		case 18:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field JoinReaderOrderingStrategyBatchSize", wireType)
			}
			m.JoinReaderOrderingStrategyBatchSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.JoinReaderOrderingStrategyBatchSize |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 19:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParallelizeMultiKeyLookupJoinsEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ParallelizeMultiKeyLookupJoinsEnabled = bool(v != 0)
		case 20:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field TrigramSimilarityThreshold", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.TrigramSimilarityThreshold = float64(math.Float64frombits(v))
		case 21:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TroubleshootingMode", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.TroubleshootingMode = bool(v != 0)
		case 22:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field JoinReaderNoOrderingStrategyBatchSize", wireType)
			}
			m.JoinReaderNoOrderingStrategyBatchSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.JoinReaderNoOrderingStrategyBatchSize |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 23:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field JoinReaderIndexJoinStrategyBatchSize", wireType)
			}
			m.JoinReaderIndexJoinStrategyBatchSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.JoinReaderIndexJoinStrategyBatchSize |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 24:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IndexJoinStreamerBatchSize", wireType)
			}
			m.IndexJoinStreamerBatchSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IndexJoinStreamerBatchSize |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 25:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DirectColumnarScansEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DirectColumnarScansEnabled = bool(v != 0)
		case 26:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultTextSearchConfig", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				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 ErrInvalidLengthSessionData
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSessionData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DefaultTextSearchConfig = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 27:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StreamerAlwaysMaintainOrdering", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.StreamerAlwaysMaintainOrdering = bool(v != 0)
		case 28:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field StreamerInOrderEagerMemoryUsageFraction", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.StreamerInOrderEagerMemoryUsageFraction = float64(math.Float64frombits(v))
		case 29:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field StreamerOutOfOrderEagerMemoryUsageFraction", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.StreamerOutOfOrderEagerMemoryUsageFraction = float64(math.Float64frombits(v))
		case 30:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field StreamerHeadOfLineOnlyFraction", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.StreamerHeadOfLineOnlyFraction = float64(math.Float64frombits(v))
		case 31:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DistsqlPlanGatewayBias", wireType)
			}
			m.DistsqlPlanGatewayBias = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DistsqlPlanGatewayBias |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipSessionData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSessionData
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DataConversionConfig) 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 ErrIntOverflowSessionData
			}
			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: DataConversionConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DataConversionConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BytesEncodeFormat", wireType)
			}
			m.BytesEncodeFormat = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BytesEncodeFormat |= lex.BytesEncodeFormat(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExtraFloatDigits", wireType)
			}
			m.ExtraFloatDigits = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExtraFloatDigits |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IntervalStyle", wireType)
			}
			m.IntervalStyle = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IntervalStyle |= duration.IntervalStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DateStyle", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSessionData
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSessionData
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSessionData
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DateStyle.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSessionData(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSessionData
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

var (
	ErrInvalidLengthSessionData        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowSessionData          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupSessionData = fmt.Errorf("proto: unexpected end of group")
)