ast

package
v0.0.0-...-1b6ad0c Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 11, 2020 License: Apache-2.0 Imports: 57 Imported by: 8

Documentation

Index

Constants

View Source 
const (
	SeqOptAs        = "AS"
	SeqOptCycle     = "CYCLE"
	SeqOptNoCycle   = "NO CYCLE"
	SeqOptOwnedBy   = "OWNED BY"
	SeqOptCache     = "CACHE"
	SeqOptIncrement = "INCREMENT"
	SeqOptMinValue  = "MINVALUE"
	SeqOptMaxValue  = "MAXVALUE"
	SeqOptStart     = "START"
	SeqOptVirtual   = "VIRTUAL"
)

Names of options on CREATE SEQUENCE.

View Source 
const (
	DistinctFuncType funcType
	AllFuncType
)

FuncExpr.Type

View Source 
const (
	CastExplicit castSyntaxMode = iota
	CastShort
	CastPrepend
)

These constants separate the syntax X::Y from CAST(X AS Y).

View Source 
const (
	AnnotateExplicit annotateSyntaxMode = iota
	AnnotateShort
)

These constants separate the syntax X:::Y from ANNOTATE_TYPE(X, Y)

View Source 
const (
	// PublicSchema is the name of the physical schema in every
	// database/catalog.
	PublicSchema string = sessiondata.PublicSchemaName
	// PublicSchemaName is the same, typed as Name.
	PublicSchemaName Name = Name(PublicSchema)
)
View Source 
const (
	// PrettyNoAlign disables alignment.
	PrettyNoAlign PrettyAlignMode = 0
	// PrettyAlignOnly aligns sub-clauses only and preserves the
	// hierarchy of logical operators.
	PrettyAlignOnly = 1
	// PrettyAlignAndDeindent does the work of PrettyAlignOnly and also
	// de-indents AND and OR operators.
	PrettyAlignAndDeindent = 2
	// PrettyAlignAndExtraIndent does the work of PrettyAlignOnly and
	// also extra indents the operands of AND and OR operators so
	// that they appear aligned but also indented.
	PrettyAlignAndExtraIndent = 3
)
View Source 
const (
	// ScrubTable describes the SCRUB operation SCRUB TABLE.
	ScrubTable = iota
	// ScrubDatabase describes the SCRUB operation SCRUB DATABASE.
	ScrubDatabase = iota
)
View Source 
const (
	AstFull  = "FULL"
	AstLeft  = "LEFT"
	AstRight = "RIGHT"
	AstCross = "CROSS"
	AstInner = "INNER"
)

JoinTableExpr.Join

View Source 
const (
	AstHash   = "HASH"
	AstLookup = "LOOKUP"
	AstMerge  = "MERGE"
)

JoinTableExpr.Hint

View Source 
const (
	AstWhere  = "WHERE"
	AstHaving = "HAVING"
)

Where.Type

View Source 
const FollowerReadTimestampFunctionName = "experimental_follower_read_timestamp"

FollowerReadTimestampFunctionName is the name of the function which can be used with AOST clauses to generate a timestamp likely to be safe for follower reads.

View Source 
const LikeTableOptAll = ^likeTableOptInvalid

LikeTableOptAll is the full LikeTableOpt bitmap.

View Source 
const MaxPlaceholderIdx = math.MaxUint16

MaxPlaceholderIdx is the maximum allowed value of a PlaceholderIdx. The pgwire protocol is limited to 2^16 placeholders, so we limit the IDs to this range as well.

View Source 
const NoColumnIdx = -1

NoColumnIdx is a special value that can be used as a "column index" to indicate that the column is not present.

View Source 
const (
	// TimestampOutputFormat is used to output all timestamps.
	TimestampOutputFormat = "2006-01-02 15:04:05.999999-07:00"
)

time.Time formats.

Variables

View Source 
var (

	// NumValAvailInteger is the set of available integer types.
	NumValAvailInteger = append(intLikeTypes, decimalLikeTypes...)
	// NumValAvailDecimalNoFraction is the set of available integral numeric types.
	NumValAvailDecimalNoFraction = append(decimalLikeTypes, intLikeTypes...)
	// NumValAvailDecimalWithFraction is the set of available fractional numeric types.
	NumValAvailDecimalWithFraction = decimalLikeTypes
)
View Source 
var (
	// StrValAvailAllParsable is the set of parsable string types.
	StrValAvailAllParsable = []*types.T{

		types.String,
		types.Bytes,
		types.Bool,
		types.Int,
		types.Float,
		types.Decimal,
		types.Date,
		types.StringArray,
		types.IntArray,
		types.Geography,
		types.Geometry,
		types.DecimalArray,
		types.Time,
		types.TimeTZ,
		types.Timestamp,
		types.TimestampTZ,
		types.Interval,
		types.Uuid,
		types.INet,
		types.Jsonb,
		types.VarBit,
		types.AnyEnum,
	}
	// StrValAvailBytes is the set of types convertible to byte array.
	StrValAvailBytes = []*types.T{types.Bytes, types.Uuid, types.String, types.AnyEnum}
)
View Source 
var (

	// DBoolTrue is a pointer to the DBool(true) value and can be used in
	// comparisons against Datum types.
	DBoolTrue = &constDBoolTrue
	// DBoolFalse is a pointer to the DBool(false) value and can be used in
	// comparisons against Datum types.
	DBoolFalse = &constDBoolFalse

	// DNull is the NULL Datum.
	DNull Datum = dNull{}

	// DZero is the zero-valued integer Datum.
	DZero = NewDInt(0)

	// DTimeMaxTimeRegex is a compiled regex for parsing the 24:00 time value.
	DTimeMaxTimeRegex = regexp.MustCompile(`^([0-9-]*(\s|T))?\s*24:00(:00(.0+)?)?\s*$`)

	// MaxSupportedTime is the maximum time we support parsing.
	MaxSupportedTime = timeutil.Unix(9224318016000-1, 999999000) // 294276-12-31 23:59:59.999999
	// MinSupportedTime is the minimum time we support parsing.
	MinSupportedTime = timeutil.Unix(-210866803200, 0) // 4714-11-24 00:00:00+00 BC
)
View Source 
var (

	// DMinTimeTZ is the min TimeTZ.
	DMinTimeTZ = NewDTimeTZFromOffset(timeofday.Min, timetz.MinTimeTZOffsetSecs)
	// DMaxTimeTZ is the max TimeTZ.
	DMaxTimeTZ = NewDTimeTZFromOffset(timeofday.Max, timetz.MaxTimeTZOffsetSecs)
)
View Source 
var (
	// DecimalCtx is the default context for decimal operations. Any change
	// in the exponent limits must still guarantee a safe conversion to the
	// postgres binary decimal format in the wire protocol, which uses an
	// int16. See pgwire/types.go.
	DecimalCtx = &apd.Context{
		Precision:   20,
		Rounding:    apd.RoundHalfUp,
		MaxExponent: 2000,
		MinExponent: -2000,

		Traps: apd.DefaultTraps &^ apd.InvalidOperation,
	}
	// ExactCtx is a decimal context with exact precision.
	ExactCtx = DecimalCtx.WithPrecision(0)
	// HighPrecisionCtx is a decimal context with high precision.
	HighPrecisionCtx = DecimalCtx.WithPrecision(2000)
	// IntermediateCtx is a decimal context with additional precision for
	// intermediate calculations to protect against order changes that can
	// happen in dist SQL. The additional 5 allows the stress test to pass.
	// See #13689 for more analysis and other algorithms.
	IntermediateCtx = DecimalCtx.WithPrecision(DecimalCtx.Precision + 5)
	// RoundCtx is a decimal context with high precision and RoundHalfEven
	// rounding.
	RoundCtx = func() *apd.Context {
		ctx := *HighPrecisionCtx
		ctx.Rounding = apd.RoundHalfEven
		return &ctx
	}()
)
View Source 
var (
	// ErrIntOutOfRange is reported when integer arithmetic overflows.
	ErrIntOutOfRange = pgerror.New(pgcode.NumericValueOutOfRange, "integer out of range")
	// ErrFloatOutOfRange is reported when float arithmetic overflows.
	ErrFloatOutOfRange = pgerror.New(pgcode.NumericValueOutOfRange, "float out of range")

	// ErrDivByZero is reported on a division by zero.
	ErrDivByZero = pgerror.New(pgcode.DivisionByZero, "division by zero")

	// ErrShiftArgOutOfRange is reported when a shift argument is out of range.
	ErrShiftArgOutOfRange = pgerror.New(pgcode.InvalidParameterValue, "shift argument out of range")
)
View Source 
var AbsentReturningClause = &NoReturningClause{}

AbsentReturningClause is a ReturningClause variant representing the absence of a RETURNING clause.

View Source 
var BinOps = map[BinaryOperator]binOpOverload{
	Bitand: {
		&BinOp{
			LeftType:   types.Int,
			RightType:  types.Int,
			ReturnType: types.Int,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				return NewDInt(MustBeDInt(left) & MustBeDInt(right)), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.VarBit,
			RightType:  types.VarBit,
			ReturnType: types.VarBit,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				lhs := MustBeDBitArray(left)
				rhs := MustBeDBitArray(right)
				if lhs.BitLen() != rhs.BitLen() {
					return nil, NewCannotMixBitArraySizesError("AND")
				}
				return &DBitArray{
					BitArray: bitarray.And(lhs.BitArray, rhs.BitArray),
				}, nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.INet,
			RightType:  types.INet,
			ReturnType: types.INet,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				ipAddr := MustBeDIPAddr(left).IPAddr
				other := MustBeDIPAddr(right).IPAddr
				newIPAddr, err := ipAddr.And(&other)
				return NewDIPAddr(DIPAddr{newIPAddr}), err
			},
			Volatility: VolatilityImmutable,
		},
	},

	Bitor: {
		&BinOp{
			LeftType:   types.Int,
			RightType:  types.Int,
			ReturnType: types.Int,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				return NewDInt(MustBeDInt(left) | MustBeDInt(right)), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.VarBit,
			RightType:  types.VarBit,
			ReturnType: types.VarBit,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				lhs := MustBeDBitArray(left)
				rhs := MustBeDBitArray(right)
				if lhs.BitLen() != rhs.BitLen() {
					return nil, NewCannotMixBitArraySizesError("OR")
				}
				return &DBitArray{
					BitArray: bitarray.Or(lhs.BitArray, rhs.BitArray),
				}, nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.INet,
			RightType:  types.INet,
			ReturnType: types.INet,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				ipAddr := MustBeDIPAddr(left).IPAddr
				other := MustBeDIPAddr(right).IPAddr
				newIPAddr, err := ipAddr.Or(&other)
				return NewDIPAddr(DIPAddr{newIPAddr}), err
			},
			Volatility: VolatilityImmutable,
		},
	},

	Bitxor: {
		&BinOp{
			LeftType:   types.Int,
			RightType:  types.Int,
			ReturnType: types.Int,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				return NewDInt(MustBeDInt(left) ^ MustBeDInt(right)), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.VarBit,
			RightType:  types.VarBit,
			ReturnType: types.VarBit,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				lhs := MustBeDBitArray(left)
				rhs := MustBeDBitArray(right)
				if lhs.BitLen() != rhs.BitLen() {
					return nil, NewCannotMixBitArraySizesError("XOR")
				}
				return &DBitArray{
					BitArray: bitarray.Xor(lhs.BitArray, rhs.BitArray),
				}, nil
			},
			Volatility: VolatilityImmutable,
		},
	},

	Plus: {
		&BinOp{
			LeftType:   types.Int,
			RightType:  types.Int,
			ReturnType: types.Int,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				a, b := MustBeDInt(left), MustBeDInt(right)
				r, ok := arith.AddWithOverflow(int64(a), int64(b))
				if !ok {
					return nil, ErrIntOutOfRange
				}
				return NewDInt(DInt(r)), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Float,
			RightType:  types.Float,
			ReturnType: types.Float,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				return NewDFloat(*left.(*DFloat) + *right.(*DFloat)), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Decimal,
			RightType:  types.Decimal,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := &left.(*DDecimal).Decimal
				r := &right.(*DDecimal).Decimal
				dd := &DDecimal{}
				_, err := ExactCtx.Add(&dd.Decimal, l, r)
				return dd, err
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Decimal,
			RightType:  types.Int,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := &left.(*DDecimal).Decimal
				r := MustBeDInt(right)
				dd := &DDecimal{}
				dd.SetInt64(int64(r))
				_, err := ExactCtx.Add(&dd.Decimal, l, &dd.Decimal)
				return dd, err
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Int,
			RightType:  types.Decimal,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := MustBeDInt(left)
				r := &right.(*DDecimal).Decimal
				dd := &DDecimal{}
				dd.SetInt64(int64(l))
				_, err := ExactCtx.Add(&dd.Decimal, &dd.Decimal, r)
				return dd, err
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Date,
			RightType:  types.Int,
			ReturnType: types.Date,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				d, err := left.(*DDate).AddDays(int64(MustBeDInt(right)))
				if err != nil {
					return nil, err
				}
				return NewDDate(d), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Int,
			RightType:  types.Date,
			ReturnType: types.Date,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				d, err := right.(*DDate).AddDays(int64(MustBeDInt(left)))
				if err != nil {
					return nil, err
				}
				return NewDDate(d), nil

			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Date,
			RightType:  types.Time,
			ReturnType: types.Timestamp,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				leftTime, err := left.(*DDate).ToTime()
				if err != nil {
					return nil, err
				}
				t := time.Duration(*right.(*DTime)) * time.Microsecond
				return MakeDTimestamp(leftTime.Add(t), time.Microsecond)
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Time,
			RightType:  types.Date,
			ReturnType: types.Timestamp,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				rightTime, err := right.(*DDate).ToTime()
				if err != nil {
					return nil, err
				}
				t := time.Duration(*left.(*DTime)) * time.Microsecond
				return MakeDTimestamp(rightTime.Add(t), time.Microsecond)
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Date,
			RightType:  types.TimeTZ,
			ReturnType: types.TimestampTZ,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				leftTime, err := left.(*DDate).ToTime()
				if err != nil {
					return nil, err
				}
				t := leftTime.Add(right.(*DTimeTZ).ToDuration())
				return MakeDTimestampTZ(t, time.Microsecond)
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.TimeTZ,
			RightType:  types.Date,
			ReturnType: types.TimestampTZ,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				rightTime, err := right.(*DDate).ToTime()
				if err != nil {
					return nil, err
				}
				t := rightTime.Add(left.(*DTimeTZ).ToDuration())
				return MakeDTimestampTZ(t, time.Microsecond)
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Time,
			RightType:  types.Interval,
			ReturnType: types.Time,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				t := timeofday.TimeOfDay(*left.(*DTime))
				return MakeDTime(t.Add(right.(*DInterval).Duration)), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Interval,
			RightType:  types.Time,
			ReturnType: types.Time,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				t := timeofday.TimeOfDay(*right.(*DTime))
				return MakeDTime(t.Add(left.(*DInterval).Duration)), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.TimeTZ,
			RightType:  types.Interval,
			ReturnType: types.TimeTZ,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				t := left.(*DTimeTZ)
				duration := right.(*DInterval).Duration
				return NewDTimeTZFromOffset(t.Add(duration), t.OffsetSecs), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Interval,
			RightType:  types.TimeTZ,
			ReturnType: types.TimeTZ,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				t := right.(*DTimeTZ)
				duration := left.(*DInterval).Duration
				return NewDTimeTZFromOffset(t.Add(duration), t.OffsetSecs), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Timestamp,
			RightType:  types.Interval,
			ReturnType: types.Timestamp,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				return MakeDTimestamp(duration.Add(
					left.(*DTimestamp).Time, right.(*DInterval).Duration), time.Microsecond)
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Interval,
			RightType:  types.Timestamp,
			ReturnType: types.Timestamp,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				return MakeDTimestamp(duration.Add(
					right.(*DTimestamp).Time, left.(*DInterval).Duration), time.Microsecond)
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.TimestampTZ,
			RightType:  types.Interval,
			ReturnType: types.TimestampTZ,
			Fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {

				t := duration.Add(left.(*DTimestampTZ).Time.In(ctx.GetLocation()), right.(*DInterval).Duration)
				return MakeDTimestampTZ(t, time.Microsecond)
			},
			Volatility: VolatilityStable,
		},
		&BinOp{
			LeftType:   types.Interval,
			RightType:  types.TimestampTZ,
			ReturnType: types.TimestampTZ,
			Fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {

				t := duration.Add(right.(*DTimestampTZ).Time.In(ctx.GetLocation()), left.(*DInterval).Duration)
				return MakeDTimestampTZ(t, time.Microsecond)
			},
			Volatility: VolatilityStable,
		},
		&BinOp{
			LeftType:   types.Interval,
			RightType:  types.Interval,
			ReturnType: types.Interval,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				return &DInterval{Duration: left.(*DInterval).Duration.Add(right.(*DInterval).Duration)}, nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Date,
			RightType:  types.Interval,
			ReturnType: types.Timestamp,
			Fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
				leftTime, err := left.(*DDate).ToTime()
				if err != nil {
					return nil, err
				}
				t := duration.Add(leftTime, right.(*DInterval).Duration)
				return MakeDTimestamp(t, time.Microsecond)
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Interval,
			RightType:  types.Date,
			ReturnType: types.Timestamp,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				rightTime, err := right.(*DDate).ToTime()
				if err != nil {
					return nil, err
				}
				t := duration.Add(rightTime, left.(*DInterval).Duration)
				return MakeDTimestamp(t, time.Microsecond)
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.INet,
			RightType:  types.Int,
			ReturnType: types.INet,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				ipAddr := MustBeDIPAddr(left).IPAddr
				i := MustBeDInt(right)
				newIPAddr, err := ipAddr.Add(int64(i))
				return NewDIPAddr(DIPAddr{newIPAddr}), err
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Int,
			RightType:  types.INet,
			ReturnType: types.INet,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				i := MustBeDInt(left)
				ipAddr := MustBeDIPAddr(right).IPAddr
				newIPAddr, err := ipAddr.Add(int64(i))
				return NewDIPAddr(DIPAddr{newIPAddr}), err
			},
			Volatility: VolatilityImmutable,
		},
	},

	Minus: {
		&BinOp{
			LeftType:   types.Int,
			RightType:  types.Int,
			ReturnType: types.Int,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				a, b := MustBeDInt(left), MustBeDInt(right)
				r, ok := arith.SubWithOverflow(int64(a), int64(b))
				if !ok {
					return nil, ErrIntOutOfRange
				}
				return NewDInt(DInt(r)), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Float,
			RightType:  types.Float,
			ReturnType: types.Float,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				return NewDFloat(*left.(*DFloat) - *right.(*DFloat)), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Decimal,
			RightType:  types.Decimal,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := &left.(*DDecimal).Decimal
				r := &right.(*DDecimal).Decimal
				dd := &DDecimal{}
				_, err := ExactCtx.Sub(&dd.Decimal, l, r)
				return dd, err
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Decimal,
			RightType:  types.Int,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := &left.(*DDecimal).Decimal
				r := MustBeDInt(right)
				dd := &DDecimal{}
				dd.SetInt64(int64(r))
				_, err := ExactCtx.Sub(&dd.Decimal, l, &dd.Decimal)
				return dd, err
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Int,
			RightType:  types.Decimal,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := MustBeDInt(left)
				r := &right.(*DDecimal).Decimal
				dd := &DDecimal{}
				dd.SetInt64(int64(l))
				_, err := ExactCtx.Sub(&dd.Decimal, &dd.Decimal, r)
				return dd, err
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Date,
			RightType:  types.Int,
			ReturnType: types.Date,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				d, err := left.(*DDate).SubDays(int64(MustBeDInt(right)))
				if err != nil {
					return nil, err
				}
				return NewDDate(d), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Date,
			RightType:  types.Date,
			ReturnType: types.Int,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l, r := left.(*DDate).Date, right.(*DDate).Date
				if !l.IsFinite() || !r.IsFinite() {
					return nil, pgerror.New(pgcode.DatetimeFieldOverflow, "cannot subtract infinite dates")
				}
				a := l.PGEpochDays()
				b := r.PGEpochDays()

				return NewDInt(DInt(int64(a) - int64(b))), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Date,
			RightType:  types.Time,
			ReturnType: types.Timestamp,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				leftTime, err := left.(*DDate).ToTime()
				if err != nil {
					return nil, err
				}
				t := time.Duration(*right.(*DTime)) * time.Microsecond
				return MakeDTimestamp(leftTime.Add(-1*t), time.Microsecond)
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Time,
			RightType:  types.Time,
			ReturnType: types.Interval,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				t1 := timeofday.TimeOfDay(*left.(*DTime))
				t2 := timeofday.TimeOfDay(*right.(*DTime))
				diff := timeofday.Difference(t1, t2)
				return &DInterval{Duration: diff}, nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Timestamp,
			RightType:  types.Timestamp,
			ReturnType: types.Interval,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				nanos := left.(*DTimestamp).Sub(right.(*DTimestamp).Time).Nanoseconds()
				return &DInterval{Duration: duration.MakeNormalizedDuration(nanos, 0, 0)}, nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.TimestampTZ,
			RightType:  types.TimestampTZ,
			ReturnType: types.Interval,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				nanos := left.(*DTimestampTZ).Sub(right.(*DTimestampTZ).Time).Nanoseconds()
				return &DInterval{Duration: duration.MakeNormalizedDuration(nanos, 0, 0)}, nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Timestamp,
			RightType:  types.TimestampTZ,
			ReturnType: types.Interval,
			Fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {

				stripped, err := right.(*DTimestampTZ).stripTimeZone(ctx)
				if err != nil {
					return nil, err
				}
				nanos := left.(*DTimestamp).Sub(stripped.Time).Nanoseconds()
				return &DInterval{Duration: duration.MakeNormalizedDuration(nanos, 0, 0)}, nil
			},
			Volatility: VolatilityStable,
		},
		&BinOp{
			LeftType:   types.TimestampTZ,
			RightType:  types.Timestamp,
			ReturnType: types.Interval,
			Fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {

				stripped, err := left.(*DTimestampTZ).stripTimeZone(ctx)
				if err != nil {
					return nil, err
				}
				nanos := stripped.Sub(right.(*DTimestamp).Time).Nanoseconds()
				return &DInterval{Duration: duration.MakeNormalizedDuration(nanos, 0, 0)}, nil
			},
			Volatility: VolatilityStable,
		},
		&BinOp{
			LeftType:   types.Time,
			RightType:  types.Interval,
			ReturnType: types.Time,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				t := timeofday.TimeOfDay(*left.(*DTime))
				return MakeDTime(t.Add(right.(*DInterval).Duration.Mul(-1))), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.TimeTZ,
			RightType:  types.Interval,
			ReturnType: types.TimeTZ,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				t := left.(*DTimeTZ)
				duration := right.(*DInterval).Duration
				return NewDTimeTZFromOffset(t.Add(duration.Mul(-1)), t.OffsetSecs), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Timestamp,
			RightType:  types.Interval,
			ReturnType: types.Timestamp,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				return MakeDTimestamp(duration.Add(
					left.(*DTimestamp).Time, right.(*DInterval).Duration.Mul(-1)), time.Microsecond)
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.TimestampTZ,
			RightType:  types.Interval,
			ReturnType: types.TimestampTZ,
			Fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
				t := duration.Add(
					left.(*DTimestampTZ).Time.In(ctx.GetLocation()),
					right.(*DInterval).Duration.Mul(-1),
				)
				return MakeDTimestampTZ(t, time.Microsecond)
			},
			Volatility: VolatilityStable,
		},
		&BinOp{
			LeftType:   types.Date,
			RightType:  types.Interval,
			ReturnType: types.Timestamp,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				leftTime, err := left.(*DDate).ToTime()
				if err != nil {
					return nil, err
				}
				t := duration.Add(leftTime, right.(*DInterval).Duration.Mul(-1))
				return MakeDTimestamp(t, time.Microsecond)
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Interval,
			RightType:  types.Interval,
			ReturnType: types.Interval,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				return &DInterval{Duration: left.(*DInterval).Duration.Sub(right.(*DInterval).Duration)}, nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Jsonb,
			RightType:  types.String,
			ReturnType: types.Jsonb,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				j, _, err := left.(*DJSON).JSON.RemoveString(string(MustBeDString(right)))
				if err != nil {
					return nil, err
				}
				return &DJSON{j}, nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Jsonb,
			RightType:  types.Int,
			ReturnType: types.Jsonb,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				j, _, err := left.(*DJSON).JSON.RemoveIndex(int(MustBeDInt(right)))
				if err != nil {
					return nil, err
				}
				return &DJSON{j}, nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Jsonb,
			RightType:  types.MakeArray(types.String),
			ReturnType: types.Jsonb,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				j := left.(*DJSON).JSON
				arr := *MustBeDArray(right)

				for _, str := range arr.Array {
					if str == DNull {
						continue
					}
					var err error
					j, _, err = j.RemoveString(string(MustBeDString(str)))
					if err != nil {
						return nil, err
					}
				}
				return &DJSON{j}, nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.INet,
			RightType:  types.INet,
			ReturnType: types.Int,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				ipAddr := MustBeDIPAddr(left).IPAddr
				other := MustBeDIPAddr(right).IPAddr
				diff, err := ipAddr.SubIPAddr(&other)
				return NewDInt(DInt(diff)), err
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{

			LeftType:   types.INet,
			RightType:  types.Int,
			ReturnType: types.INet,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				ipAddr := MustBeDIPAddr(left).IPAddr
				i := MustBeDInt(right)
				newIPAddr, err := ipAddr.Sub(int64(i))
				return NewDIPAddr(DIPAddr{newIPAddr}), err
			},
			Volatility: VolatilityImmutable,
		},
	},

	Mult: {
		&BinOp{
			LeftType:   types.Int,
			RightType:  types.Int,
			ReturnType: types.Int,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {

				a, b := MustBeDInt(left), MustBeDInt(right)
				c := a * b
				if a == 0 || b == 0 || a == 1 || b == 1 {

				} else if a == math.MinInt64 || b == math.MinInt64 {

					return nil, ErrIntOutOfRange
				} else if c/b != a {
					return nil, ErrIntOutOfRange
				}
				return NewDInt(c), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Float,
			RightType:  types.Float,
			ReturnType: types.Float,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				return NewDFloat(*left.(*DFloat) * *right.(*DFloat)), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Decimal,
			RightType:  types.Decimal,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := &left.(*DDecimal).Decimal
				r := &right.(*DDecimal).Decimal
				dd := &DDecimal{}
				_, err := ExactCtx.Mul(&dd.Decimal, l, r)
				return dd, err
			},
			Volatility: VolatilityImmutable,
		},

		&BinOp{
			LeftType:   types.Decimal,
			RightType:  types.Int,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := &left.(*DDecimal).Decimal
				r := MustBeDInt(right)
				dd := &DDecimal{}
				dd.SetInt64(int64(r))
				_, err := ExactCtx.Mul(&dd.Decimal, l, &dd.Decimal)
				return dd, err
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Int,
			RightType:  types.Decimal,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := MustBeDInt(left)
				r := &right.(*DDecimal).Decimal
				dd := &DDecimal{}
				dd.SetInt64(int64(l))
				_, err := ExactCtx.Mul(&dd.Decimal, &dd.Decimal, r)
				return dd, err
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Int,
			RightType:  types.Interval,
			ReturnType: types.Interval,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				return &DInterval{Duration: right.(*DInterval).Duration.Mul(int64(MustBeDInt(left)))}, nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Interval,
			RightType:  types.Int,
			ReturnType: types.Interval,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				return &DInterval{Duration: left.(*DInterval).Duration.Mul(int64(MustBeDInt(right)))}, nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Interval,
			RightType:  types.Float,
			ReturnType: types.Interval,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				r := float64(*right.(*DFloat))
				return &DInterval{Duration: left.(*DInterval).Duration.MulFloat(r)}, nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Float,
			RightType:  types.Interval,
			ReturnType: types.Interval,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := float64(*left.(*DFloat))
				return &DInterval{Duration: right.(*DInterval).Duration.MulFloat(l)}, nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Decimal,
			RightType:  types.Interval,
			ReturnType: types.Interval,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := &left.(*DDecimal).Decimal
				t, err := l.Float64()
				if err != nil {
					return nil, err
				}
				return &DInterval{Duration: right.(*DInterval).Duration.MulFloat(t)}, nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Interval,
			RightType:  types.Decimal,
			ReturnType: types.Interval,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				r := &right.(*DDecimal).Decimal
				t, err := r.Float64()
				if err != nil {
					return nil, err
				}
				return &DInterval{Duration: left.(*DInterval).Duration.MulFloat(t)}, nil
			},
			Volatility: VolatilityImmutable,
		},
	},

	Div: {
		&BinOp{
			LeftType:   types.Int,
			RightType:  types.Int,
			ReturnType: types.Decimal,
			Fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
				rInt := MustBeDInt(right)
				if rInt == 0 {
					return nil, ErrDivByZero
				}
				div := ctx.getTmpDec().SetInt64(int64(rInt))
				dd := &DDecimal{}
				dd.SetInt64(int64(MustBeDInt(left)))
				_, err := DecimalCtx.Quo(&dd.Decimal, &dd.Decimal, div)
				return dd, err
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Float,
			RightType:  types.Float,
			ReturnType: types.Float,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				r := *right.(*DFloat)
				if r == 0.0 {
					return nil, ErrDivByZero
				}
				return NewDFloat(*left.(*DFloat) / r), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Decimal,
			RightType:  types.Decimal,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := &left.(*DDecimal).Decimal
				r := &right.(*DDecimal).Decimal
				if r.IsZero() {
					return nil, ErrDivByZero
				}
				dd := &DDecimal{}
				_, err := DecimalCtx.Quo(&dd.Decimal, l, r)
				return dd, err
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Decimal,
			RightType:  types.Int,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := &left.(*DDecimal).Decimal
				r := MustBeDInt(right)
				if r == 0 {
					return nil, ErrDivByZero
				}
				dd := &DDecimal{}
				dd.SetInt64(int64(r))
				_, err := DecimalCtx.Quo(&dd.Decimal, l, &dd.Decimal)
				return dd, err
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Int,
			RightType:  types.Decimal,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := MustBeDInt(left)
				r := &right.(*DDecimal).Decimal
				if r.IsZero() {
					return nil, ErrDivByZero
				}
				dd := &DDecimal{}
				dd.SetInt64(int64(l))
				_, err := DecimalCtx.Quo(&dd.Decimal, &dd.Decimal, r)
				return dd, err
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Interval,
			RightType:  types.Int,
			ReturnType: types.Interval,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				rInt := MustBeDInt(right)
				if rInt == 0 {
					return nil, ErrDivByZero
				}
				return &DInterval{Duration: left.(*DInterval).Duration.Div(int64(rInt))}, nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Interval,
			RightType:  types.Float,
			ReturnType: types.Interval,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				r := float64(*right.(*DFloat))
				if r == 0.0 {
					return nil, ErrDivByZero
				}
				return &DInterval{Duration: left.(*DInterval).Duration.DivFloat(r)}, nil
			},
			Volatility: VolatilityImmutable,
		},
	},

	FloorDiv: {
		&BinOp{
			LeftType:   types.Int,
			RightType:  types.Int,
			ReturnType: types.Int,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				rInt := MustBeDInt(right)
				if rInt == 0 {
					return nil, ErrDivByZero
				}
				return NewDInt(MustBeDInt(left) / rInt), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Float,
			RightType:  types.Float,
			ReturnType: types.Float,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := float64(*left.(*DFloat))
				r := float64(*right.(*DFloat))
				if r == 0.0 {
					return nil, ErrDivByZero
				}
				return NewDFloat(DFloat(math.Trunc(l / r))), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Decimal,
			RightType:  types.Decimal,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := &left.(*DDecimal).Decimal
				r := &right.(*DDecimal).Decimal
				if r.IsZero() {
					return nil, ErrDivByZero
				}
				dd := &DDecimal{}
				_, err := HighPrecisionCtx.QuoInteger(&dd.Decimal, l, r)
				return dd, err
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Decimal,
			RightType:  types.Int,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := &left.(*DDecimal).Decimal
				r := MustBeDInt(right)
				if r == 0 {
					return nil, ErrDivByZero
				}
				dd := &DDecimal{}
				dd.SetInt64(int64(r))
				_, err := HighPrecisionCtx.QuoInteger(&dd.Decimal, l, &dd.Decimal)
				return dd, err
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Int,
			RightType:  types.Decimal,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := MustBeDInt(left)
				r := &right.(*DDecimal).Decimal
				if r.IsZero() {
					return nil, ErrDivByZero
				}
				dd := &DDecimal{}
				dd.SetInt64(int64(l))
				_, err := HighPrecisionCtx.QuoInteger(&dd.Decimal, &dd.Decimal, r)
				return dd, err
			},
			Volatility: VolatilityImmutable,
		},
	},

	Mod: {
		&BinOp{
			LeftType:   types.Int,
			RightType:  types.Int,
			ReturnType: types.Int,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				r := MustBeDInt(right)
				if r == 0 {
					return nil, ErrDivByZero
				}
				return NewDInt(MustBeDInt(left) % r), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Float,
			RightType:  types.Float,
			ReturnType: types.Float,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := float64(*left.(*DFloat))
				r := float64(*right.(*DFloat))
				if r == 0.0 {
					return nil, ErrDivByZero
				}
				return NewDFloat(DFloat(math.Mod(l, r))), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Decimal,
			RightType:  types.Decimal,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := &left.(*DDecimal).Decimal
				r := &right.(*DDecimal).Decimal
				if r.IsZero() {
					return nil, ErrDivByZero
				}
				dd := &DDecimal{}
				_, err := HighPrecisionCtx.Rem(&dd.Decimal, l, r)
				return dd, err
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Decimal,
			RightType:  types.Int,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := &left.(*DDecimal).Decimal
				r := MustBeDInt(right)
				if r == 0 {
					return nil, ErrDivByZero
				}
				dd := &DDecimal{}
				dd.SetInt64(int64(r))
				_, err := HighPrecisionCtx.Rem(&dd.Decimal, l, &dd.Decimal)
				return dd, err
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Int,
			RightType:  types.Decimal,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := MustBeDInt(left)
				r := &right.(*DDecimal).Decimal
				if r.IsZero() {
					return nil, ErrDivByZero
				}
				dd := &DDecimal{}
				dd.SetInt64(int64(l))
				_, err := HighPrecisionCtx.Rem(&dd.Decimal, &dd.Decimal, r)
				return dd, err
			},
			Volatility: VolatilityImmutable,
		},
	},

	Concat: {
		&BinOp{
			LeftType:   types.String,
			RightType:  types.String,
			ReturnType: types.String,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				return NewDString(string(MustBeDString(left) + MustBeDString(right))), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Bytes,
			RightType:  types.Bytes,
			ReturnType: types.Bytes,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				return NewDBytes(*left.(*DBytes) + *right.(*DBytes)), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.VarBit,
			RightType:  types.VarBit,
			ReturnType: types.VarBit,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				lhs := MustBeDBitArray(left)
				rhs := MustBeDBitArray(right)
				return &DBitArray{
					BitArray: bitarray.Concat(lhs.BitArray, rhs.BitArray),
				}, nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Jsonb,
			RightType:  types.Jsonb,
			ReturnType: types.Jsonb,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				j, err := MustBeDJSON(left).JSON.Concat(MustBeDJSON(right).JSON)
				if err != nil {
					return nil, err
				}
				return &DJSON{j}, nil
			},
			Volatility: VolatilityImmutable,
		},
	},

	LShift: {
		&BinOp{
			LeftType:   types.Int,
			RightType:  types.Int,
			ReturnType: types.Int,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				rval := MustBeDInt(right)
				if rval < 0 || rval >= 64 {
					telemetry.Inc(sqltelemetry.LargeLShiftArgumentCounter)
					return nil, ErrShiftArgOutOfRange
				}
				return NewDInt(MustBeDInt(left) << uint(rval)), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.VarBit,
			RightType:  types.Int,
			ReturnType: types.VarBit,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				lhs := MustBeDBitArray(left)
				rhs := MustBeDInt(right)
				return &DBitArray{
					BitArray: lhs.BitArray.LeftShiftAny(int64(rhs)),
				}, nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.INet,
			RightType:  types.INet,
			ReturnType: types.Bool,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				ipAddr := MustBeDIPAddr(left).IPAddr
				other := MustBeDIPAddr(right).IPAddr
				return MakeDBool(DBool(ipAddr.ContainedBy(&other))), nil
			},
			Volatility: VolatilityImmutable,
		},
	},

	RShift: {
		&BinOp{
			LeftType:   types.Int,
			RightType:  types.Int,
			ReturnType: types.Int,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				rval := MustBeDInt(right)
				if rval < 0 || rval >= 64 {
					telemetry.Inc(sqltelemetry.LargeRShiftArgumentCounter)
					return nil, ErrShiftArgOutOfRange
				}
				return NewDInt(MustBeDInt(left) >> uint(rval)), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.VarBit,
			RightType:  types.Int,
			ReturnType: types.VarBit,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				lhs := MustBeDBitArray(left)
				rhs := MustBeDInt(right)
				return &DBitArray{
					BitArray: lhs.BitArray.LeftShiftAny(-int64(rhs)),
				}, nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.INet,
			RightType:  types.INet,
			ReturnType: types.Bool,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				ipAddr := MustBeDIPAddr(left).IPAddr
				other := MustBeDIPAddr(right).IPAddr
				return MakeDBool(DBool(ipAddr.Contains(&other))), nil
			},
			Volatility: VolatilityImmutable,
		},
	},

	Pow: {
		&BinOp{
			LeftType:   types.Int,
			RightType:  types.Int,
			ReturnType: types.Int,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				return IntPow(MustBeDInt(left), MustBeDInt(right))
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Float,
			RightType:  types.Float,
			ReturnType: types.Float,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				f := math.Pow(float64(*left.(*DFloat)), float64(*right.(*DFloat)))
				return NewDFloat(DFloat(f)), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Decimal,
			RightType:  types.Decimal,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := &left.(*DDecimal).Decimal
				r := &right.(*DDecimal).Decimal
				dd := &DDecimal{}
				_, err := DecimalCtx.Pow(&dd.Decimal, l, r)
				return dd, err
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Decimal,
			RightType:  types.Int,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := &left.(*DDecimal).Decimal
				r := MustBeDInt(right)
				dd := &DDecimal{}
				dd.SetInt64(int64(r))
				_, err := DecimalCtx.Pow(&dd.Decimal, l, &dd.Decimal)
				return dd, err
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Int,
			RightType:  types.Decimal,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				l := MustBeDInt(left)
				r := &right.(*DDecimal).Decimal
				dd := &DDecimal{}
				dd.SetInt64(int64(l))
				_, err := DecimalCtx.Pow(&dd.Decimal, &dd.Decimal, r)
				return dd, err
			},
			Volatility: VolatilityImmutable,
		},
	},

	JSONFetchVal: {
		&BinOp{
			LeftType:   types.Jsonb,
			RightType:  types.String,
			ReturnType: types.Jsonb,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				j, err := left.(*DJSON).JSON.FetchValKey(string(MustBeDString(right)))
				if err != nil {
					return nil, err
				}
				if j == nil {
					return DNull, nil
				}
				return &DJSON{j}, nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Jsonb,
			RightType:  types.Int,
			ReturnType: types.Jsonb,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				j, err := left.(*DJSON).JSON.FetchValIdx(int(MustBeDInt(right)))
				if err != nil {
					return nil, err
				}
				if j == nil {
					return DNull, nil
				}
				return &DJSON{j}, nil
			},
			Volatility: VolatilityImmutable,
		},
	},

	JSONFetchValPath: {
		&BinOp{
			LeftType:   types.Jsonb,
			RightType:  types.MakeArray(types.String),
			ReturnType: types.Jsonb,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				return getJSONPath(*left.(*DJSON), *MustBeDArray(right))
			},
			Volatility: VolatilityImmutable,
		},
	},

	JSONFetchText: {
		&BinOp{
			LeftType:   types.Jsonb,
			RightType:  types.String,
			ReturnType: types.String,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				res, err := left.(*DJSON).JSON.FetchValKey(string(MustBeDString(right)))
				if err != nil {
					return nil, err
				}
				if res == nil {
					return DNull, nil
				}
				text, err := res.AsText()
				if err != nil {
					return nil, err
				}
				if text == nil {
					return DNull, nil
				}
				return NewDString(*text), nil
			},
			Volatility: VolatilityImmutable,
		},
		&BinOp{
			LeftType:   types.Jsonb,
			RightType:  types.Int,
			ReturnType: types.String,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				res, err := left.(*DJSON).JSON.FetchValIdx(int(MustBeDInt(right)))
				if err != nil {
					return nil, err
				}
				if res == nil {
					return DNull, nil
				}
				text, err := res.AsText()
				if err != nil {
					return nil, err
				}
				if text == nil {
					return DNull, nil
				}
				return NewDString(*text), nil
			},
			Volatility: VolatilityImmutable,
		},
	},

	JSONFetchTextPath: {
		&BinOp{
			LeftType:   types.Jsonb,
			RightType:  types.MakeArray(types.String),
			ReturnType: types.String,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				res, err := getJSONPath(*left.(*DJSON), *MustBeDArray(right))
				if err != nil {
					return nil, err
				}
				if res == DNull {
					return DNull, nil
				}
				text, err := res.(*DJSON).JSON.AsText()
				if err != nil {
					return nil, err
				}
				if text == nil {
					return DNull, nil
				}
				return NewDString(*text), nil
			},
			Volatility: VolatilityImmutable,
		},
	},
}

BinOps contains the binary operations indexed by operation type.

View Source 
var CmpOps = cmpOpFixups(map[ComparisonOperator]cmpOpOverload{
	EQ: {

		makeEqFn(types.AnyEnum, types.AnyEnum, VolatilityImmutable),
		makeEqFn(types.Bool, types.Bool, VolatilityLeakProof),
		makeEqFn(types.Bytes, types.Bytes, VolatilityLeakProof),
		makeEqFn(types.Date, types.Date, VolatilityLeakProof),
		makeEqFn(types.Decimal, types.Decimal, VolatilityImmutable),

		makeEqFn(types.AnyCollatedString, types.AnyCollatedString, VolatilityLeakProof),
		makeEqFn(types.Float, types.Float, VolatilityLeakProof),
		makeEqFn(types.Geography, types.Geography, VolatilityLeakProof),
		makeEqFn(types.Geometry, types.Geometry, VolatilityLeakProof),
		makeEqFn(types.INet, types.INet, VolatilityLeakProof),
		makeEqFn(types.Int, types.Int, VolatilityLeakProof),
		makeEqFn(types.Interval, types.Interval, VolatilityLeakProof),
		makeEqFn(types.Jsonb, types.Jsonb, VolatilityImmutable),
		makeEqFn(types.Oid, types.Oid, VolatilityLeakProof),
		makeEqFn(types.String, types.String, VolatilityLeakProof),
		makeEqFn(types.Time, types.Time, VolatilityLeakProof),
		makeEqFn(types.TimeTZ, types.TimeTZ, VolatilityLeakProof),
		makeEqFn(types.Timestamp, types.Timestamp, VolatilityLeakProof),
		makeEqFn(types.TimestampTZ, types.TimestampTZ, VolatilityLeakProof),
		makeEqFn(types.Uuid, types.Uuid, VolatilityLeakProof),
		makeEqFn(types.VarBit, types.VarBit, VolatilityLeakProof),

		makeEqFn(types.Date, types.Timestamp, VolatilityImmutable),
		makeEqFn(types.Date, types.TimestampTZ, VolatilityStable),
		makeEqFn(types.Decimal, types.Float, VolatilityLeakProof),
		makeEqFn(types.Decimal, types.Int, VolatilityLeakProof),
		makeEqFn(types.Float, types.Decimal, VolatilityLeakProof),
		makeEqFn(types.Float, types.Int, VolatilityLeakProof),
		makeEqFn(types.Int, types.Decimal, VolatilityLeakProof),
		makeEqFn(types.Int, types.Float, VolatilityLeakProof),
		makeEqFn(types.Timestamp, types.Date, VolatilityImmutable),
		makeEqFn(types.Timestamp, types.TimestampTZ, VolatilityStable),
		makeEqFn(types.TimestampTZ, types.Date, VolatilityStable),
		makeEqFn(types.TimestampTZ, types.Timestamp, VolatilityStable),
		makeEqFn(types.Time, types.TimeTZ, VolatilityStable),
		makeEqFn(types.TimeTZ, types.Time, VolatilityStable),

		&CmpOp{
			LeftType:  types.AnyTuple,
			RightType: types.AnyTuple,
			Fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
				return cmpOpTupleFn(ctx, *left.(*DTuple), *right.(*DTuple), EQ), nil
			},
			Volatility: VolatilityImmutable,
		},
	},

	LT: {

		makeLtFn(types.AnyEnum, types.AnyEnum, VolatilityImmutable),
		makeLtFn(types.Bool, types.Bool, VolatilityLeakProof),
		makeLtFn(types.Bytes, types.Bytes, VolatilityLeakProof),
		makeLtFn(types.Date, types.Date, VolatilityLeakProof),
		makeLtFn(types.Decimal, types.Decimal, VolatilityImmutable),
		makeLtFn(types.AnyCollatedString, types.AnyCollatedString, VolatilityLeakProof),

		makeLtFn(types.Float, types.Float, VolatilityLeakProof),
		makeLtFn(types.Geography, types.Geography, VolatilityLeakProof),
		makeLtFn(types.Geometry, types.Geometry, VolatilityLeakProof),
		makeLtFn(types.INet, types.INet, VolatilityLeakProof),
		makeLtFn(types.Int, types.Int, VolatilityLeakProof),
		makeLtFn(types.Interval, types.Interval, VolatilityLeakProof),
		makeLtFn(types.Oid, types.Oid, VolatilityLeakProof),
		makeLtFn(types.String, types.String, VolatilityLeakProof),
		makeLtFn(types.Time, types.Time, VolatilityLeakProof),
		makeLtFn(types.TimeTZ, types.TimeTZ, VolatilityLeakProof),
		makeLtFn(types.Timestamp, types.Timestamp, VolatilityLeakProof),
		makeLtFn(types.TimestampTZ, types.TimestampTZ, VolatilityLeakProof),
		makeLtFn(types.Uuid, types.Uuid, VolatilityLeakProof),
		makeLtFn(types.VarBit, types.VarBit, VolatilityLeakProof),

		makeLtFn(types.Date, types.Timestamp, VolatilityImmutable),
		makeLtFn(types.Date, types.TimestampTZ, VolatilityStable),
		makeLtFn(types.Decimal, types.Float, VolatilityLeakProof),
		makeLtFn(types.Decimal, types.Int, VolatilityLeakProof),
		makeLtFn(types.Float, types.Decimal, VolatilityLeakProof),
		makeLtFn(types.Float, types.Int, VolatilityLeakProof),
		makeLtFn(types.Int, types.Decimal, VolatilityLeakProof),
		makeLtFn(types.Int, types.Float, VolatilityLeakProof),
		makeLtFn(types.Timestamp, types.Date, VolatilityImmutable),
		makeLtFn(types.Timestamp, types.TimestampTZ, VolatilityStable),
		makeLtFn(types.TimestampTZ, types.Date, VolatilityStable),
		makeLtFn(types.TimestampTZ, types.Timestamp, VolatilityStable),
		makeLtFn(types.Time, types.TimeTZ, VolatilityStable),
		makeLtFn(types.TimeTZ, types.Time, VolatilityStable),

		&CmpOp{
			LeftType:  types.AnyTuple,
			RightType: types.AnyTuple,
			Fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
				return cmpOpTupleFn(ctx, *left.(*DTuple), *right.(*DTuple), LT), nil
			},
			Volatility: VolatilityImmutable,
		},
	},

	LE: {

		makeLeFn(types.AnyEnum, types.AnyEnum, VolatilityImmutable),
		makeLeFn(types.Bool, types.Bool, VolatilityLeakProof),
		makeLeFn(types.Bytes, types.Bytes, VolatilityLeakProof),
		makeLeFn(types.Date, types.Date, VolatilityLeakProof),
		makeLeFn(types.Decimal, types.Decimal, VolatilityImmutable),

		makeLeFn(types.AnyCollatedString, types.AnyCollatedString, VolatilityLeakProof),
		makeLeFn(types.Float, types.Float, VolatilityLeakProof),
		makeLeFn(types.Geography, types.Geography, VolatilityLeakProof),
		makeLeFn(types.Geometry, types.Geometry, VolatilityLeakProof),
		makeLeFn(types.INet, types.INet, VolatilityLeakProof),
		makeLeFn(types.Int, types.Int, VolatilityLeakProof),
		makeLeFn(types.Interval, types.Interval, VolatilityLeakProof),
		makeLeFn(types.Oid, types.Oid, VolatilityLeakProof),
		makeLeFn(types.String, types.String, VolatilityLeakProof),
		makeLeFn(types.Time, types.Time, VolatilityLeakProof),
		makeLeFn(types.TimeTZ, types.TimeTZ, VolatilityLeakProof),
		makeLeFn(types.Timestamp, types.Timestamp, VolatilityLeakProof),
		makeLeFn(types.TimestampTZ, types.TimestampTZ, VolatilityLeakProof),
		makeLeFn(types.Uuid, types.Uuid, VolatilityLeakProof),
		makeLeFn(types.VarBit, types.VarBit, VolatilityLeakProof),

		makeLeFn(types.Date, types.Timestamp, VolatilityImmutable),
		makeLeFn(types.Date, types.TimestampTZ, VolatilityStable),
		makeLeFn(types.Decimal, types.Float, VolatilityLeakProof),
		makeLeFn(types.Decimal, types.Int, VolatilityLeakProof),
		makeLeFn(types.Float, types.Decimal, VolatilityLeakProof),
		makeLeFn(types.Float, types.Int, VolatilityLeakProof),
		makeLeFn(types.Int, types.Decimal, VolatilityLeakProof),
		makeLeFn(types.Int, types.Float, VolatilityLeakProof),
		makeLeFn(types.Timestamp, types.Date, VolatilityImmutable),
		makeLeFn(types.Timestamp, types.TimestampTZ, VolatilityStable),
		makeLeFn(types.TimestampTZ, types.Date, VolatilityStable),
		makeLeFn(types.TimestampTZ, types.Timestamp, VolatilityStable),
		makeLeFn(types.Time, types.TimeTZ, VolatilityStable),
		makeLeFn(types.TimeTZ, types.Time, VolatilityStable),

		&CmpOp{
			LeftType:  types.AnyTuple,
			RightType: types.AnyTuple,
			Fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
				return cmpOpTupleFn(ctx, *left.(*DTuple), *right.(*DTuple), LE), nil
			},
			Volatility: VolatilityImmutable,
		},
	},

	IsNotDistinctFrom: {
		&CmpOp{
			LeftType:     types.Unknown,
			RightType:    types.Unknown,
			Fn:           cmpOpScalarIsFn,
			NullableArgs: true,

			isPreferred: true,
			Volatility:  VolatilityLeakProof,
		},

		makeIsFn(types.AnyEnum, types.AnyEnum, VolatilityImmutable),
		makeIsFn(types.Bool, types.Bool, VolatilityLeakProof),
		makeIsFn(types.Bytes, types.Bytes, VolatilityLeakProof),
		makeIsFn(types.Date, types.Date, VolatilityLeakProof),
		makeIsFn(types.Decimal, types.Decimal, VolatilityImmutable),

		makeIsFn(types.AnyCollatedString, types.AnyCollatedString, VolatilityLeakProof),
		makeIsFn(types.Float, types.Float, VolatilityLeakProof),
		makeIsFn(types.Geography, types.Geography, VolatilityLeakProof),
		makeIsFn(types.Geometry, types.Geometry, VolatilityLeakProof),
		makeIsFn(types.INet, types.INet, VolatilityLeakProof),
		makeIsFn(types.Int, types.Int, VolatilityLeakProof),
		makeIsFn(types.Interval, types.Interval, VolatilityLeakProof),
		makeIsFn(types.Jsonb, types.Jsonb, VolatilityImmutable),
		makeIsFn(types.Oid, types.Oid, VolatilityLeakProof),
		makeIsFn(types.String, types.String, VolatilityLeakProof),
		makeIsFn(types.Time, types.Time, VolatilityLeakProof),
		makeIsFn(types.TimeTZ, types.TimeTZ, VolatilityLeakProof),
		makeIsFn(types.Timestamp, types.Timestamp, VolatilityLeakProof),
		makeIsFn(types.TimestampTZ, types.TimestampTZ, VolatilityLeakProof),
		makeIsFn(types.Uuid, types.Uuid, VolatilityLeakProof),
		makeIsFn(types.VarBit, types.VarBit, VolatilityLeakProof),

		makeIsFn(types.Date, types.Timestamp, VolatilityImmutable),
		makeIsFn(types.Date, types.TimestampTZ, VolatilityStable),
		makeIsFn(types.Decimal, types.Float, VolatilityLeakProof),
		makeIsFn(types.Decimal, types.Int, VolatilityLeakProof),
		makeIsFn(types.Float, types.Decimal, VolatilityLeakProof),
		makeIsFn(types.Float, types.Int, VolatilityLeakProof),
		makeIsFn(types.Int, types.Decimal, VolatilityLeakProof),
		makeIsFn(types.Int, types.Float, VolatilityLeakProof),
		makeIsFn(types.Timestamp, types.Date, VolatilityImmutable),
		makeIsFn(types.Timestamp, types.TimestampTZ, VolatilityStable),
		makeIsFn(types.TimestampTZ, types.Date, VolatilityStable),
		makeIsFn(types.TimestampTZ, types.Timestamp, VolatilityStable),
		makeIsFn(types.Time, types.TimeTZ, VolatilityStable),
		makeIsFn(types.TimeTZ, types.Time, VolatilityStable),

		&CmpOp{
			LeftType:     types.AnyTuple,
			RightType:    types.AnyTuple,
			NullableArgs: true,
			Fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
				if left == DNull || right == DNull {
					return MakeDBool(left == DNull && right == DNull), nil
				}
				return cmpOpTupleFn(ctx, *left.(*DTuple), *right.(*DTuple), IsNotDistinctFrom), nil
			},
			Volatility: VolatilityImmutable,
		},
	},

	In: {
		makeEvalTupleIn(types.AnyEnum, VolatilityLeakProof),
		makeEvalTupleIn(types.Bool, VolatilityLeakProof),
		makeEvalTupleIn(types.Bytes, VolatilityLeakProof),
		makeEvalTupleIn(types.Date, VolatilityLeakProof),
		makeEvalTupleIn(types.Decimal, VolatilityLeakProof),
		makeEvalTupleIn(types.AnyCollatedString, VolatilityLeakProof),
		makeEvalTupleIn(types.AnyTuple, VolatilityLeakProof),
		makeEvalTupleIn(types.Float, VolatilityLeakProof),
		makeEvalTupleIn(types.Geography, VolatilityLeakProof),
		makeEvalTupleIn(types.Geometry, VolatilityLeakProof),
		makeEvalTupleIn(types.INet, VolatilityLeakProof),
		makeEvalTupleIn(types.Int, VolatilityLeakProof),
		makeEvalTupleIn(types.Interval, VolatilityLeakProof),
		makeEvalTupleIn(types.Jsonb, VolatilityLeakProof),
		makeEvalTupleIn(types.Oid, VolatilityLeakProof),
		makeEvalTupleIn(types.String, VolatilityLeakProof),
		makeEvalTupleIn(types.Time, VolatilityLeakProof),
		makeEvalTupleIn(types.TimeTZ, VolatilityLeakProof),
		makeEvalTupleIn(types.Timestamp, VolatilityLeakProof),
		makeEvalTupleIn(types.TimestampTZ, VolatilityLeakProof),
		makeEvalTupleIn(types.Uuid, VolatilityLeakProof),
		makeEvalTupleIn(types.VarBit, VolatilityLeakProof),
	},

	Like: {
		&CmpOp{
			LeftType:  types.String,
			RightType: types.String,
			Fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
				return matchLike(ctx, left, right, false)
			},
			Volatility: VolatilityLeakProof,
		},
	},

	ILike: {
		&CmpOp{
			LeftType:  types.String,
			RightType: types.String,
			Fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
				return matchLike(ctx, left, right, true)
			},
			Volatility: VolatilityLeakProof,
		},
	},

	SimilarTo: {
		&CmpOp{
			LeftType:  types.String,
			RightType: types.String,
			Fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
				key := similarToKey{s: string(MustBeDString(right)), escape: '\\'}
				return matchRegexpWithKey(ctx, left, key)
			},
			Volatility: VolatilityLeakProof,
		},
	},

	RegMatch: {
		&CmpOp{
			LeftType:  types.String,
			RightType: types.String,
			Fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
				key := regexpKey{s: string(MustBeDString(right)), caseInsensitive: false}
				return matchRegexpWithKey(ctx, left, key)
			},
			Volatility: VolatilityImmutable,
		},
	},

	RegIMatch: {
		&CmpOp{
			LeftType:  types.String,
			RightType: types.String,
			Fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
				key := regexpKey{s: string(MustBeDString(right)), caseInsensitive: true}
				return matchRegexpWithKey(ctx, left, key)
			},
			Volatility: VolatilityImmutable,
		},
	},

	JSONExists: {
		&CmpOp{
			LeftType:  types.Jsonb,
			RightType: types.String,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {
				e, err := left.(*DJSON).JSON.Exists(string(MustBeDString(right)))
				if err != nil {
					return nil, err
				}
				if e {
					return DBoolTrue, nil
				}
				return DBoolFalse, nil
			},
			Volatility: VolatilityImmutable,
		},
	},

	JSONSomeExists: {
		&CmpOp{
			LeftType:  types.Jsonb,
			RightType: types.StringArray,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {

				for _, k := range MustBeDArray(right).Array {
					if k == DNull {
						continue
					}
					e, err := left.(*DJSON).JSON.Exists(string(MustBeDString(k)))
					if err != nil {
						return nil, err
					}
					if e {
						return DBoolTrue, nil
					}
				}
				return DBoolFalse, nil
			},
			Volatility: VolatilityImmutable,
		},
	},

	JSONAllExists: {
		&CmpOp{
			LeftType:  types.Jsonb,
			RightType: types.StringArray,
			Fn: func(_ *EvalContext, left Datum, right Datum) (Datum, error) {

				for _, k := range MustBeDArray(right).Array {
					if k == DNull {
						continue
					}
					e, err := left.(*DJSON).JSON.Exists(string(MustBeDString(k)))
					if err != nil {
						return nil, err
					}
					if !e {
						return DBoolFalse, nil
					}
				}
				return DBoolTrue, nil
			},
			Volatility: VolatilityImmutable,
		},
	},

	Contains: {
		&CmpOp{
			LeftType:  types.AnyArray,
			RightType: types.AnyArray,
			Fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
				haystack := MustBeDArray(left)
				needles := MustBeDArray(right)
				return ArrayContains(ctx, haystack, needles)
			},
			Volatility: VolatilityImmutable,
		},
		&CmpOp{
			LeftType:  types.Jsonb,
			RightType: types.Jsonb,
			Fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
				c, err := json.Contains(left.(*DJSON).JSON, right.(*DJSON).JSON)
				if err != nil {
					return nil, err
				}
				return MakeDBool(DBool(c)), nil
			},
			Volatility: VolatilityImmutable,
		},
	},

	ContainedBy: {
		&CmpOp{
			LeftType:  types.AnyArray,
			RightType: types.AnyArray,
			Fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
				needles := MustBeDArray(left)
				haystack := MustBeDArray(right)
				return ArrayContains(ctx, haystack, needles)
			},
			Volatility: VolatilityImmutable,
		},
		&CmpOp{
			LeftType:  types.Jsonb,
			RightType: types.Jsonb,
			Fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
				c, err := json.Contains(right.(*DJSON).JSON, left.(*DJSON).JSON)
				if err != nil {
					return nil, err
				}
				return MakeDBool(DBool(c)), nil
			},
			Volatility: VolatilityImmutable,
		},
	},
	Overlaps: {
		&CmpOp{
			LeftType:  types.AnyArray,
			RightType: types.AnyArray,
			Fn: func(ctx *EvalContext, left Datum, right Datum) (Datum, error) {
				array := MustBeDArray(left)
				other := MustBeDArray(right)
				if !array.ParamTyp.Equivalent(other.ParamTyp) {
					return nil, pgerror.New(pgcode.DatatypeMismatch, "cannot compare arrays with different element types")
				}
				for _, needle := range array.Array {

					if needle == DNull {
						continue
					}
					for _, hay := range other.Array {
						if needle.Compare(ctx, hay) == 0 {
							return DBoolTrue, nil
						}
					}
				}
				return DBoolFalse, nil
			},
			Volatility: VolatilityImmutable,
		},
		&CmpOp{
			LeftType:  types.INet,
			RightType: types.INet,
			Fn: func(_ *EvalContext, left, right Datum) (Datum, error) {
				ipAddr := MustBeDIPAddr(left).IPAddr
				other := MustBeDIPAddr(right).IPAddr
				return MakeDBool(DBool(ipAddr.ContainsOrContainedBy(&other))), nil
			},
			Volatility: VolatilityImmutable,
		},
	},
})

CmpOps contains the comparison operations indexed by operation type.

View Source 
var DMaxIPAddr = NewDIPAddr(DIPAddr{ipaddr.IPAddr{Family: ipaddr.IPv6family, Addr: dIPv6max, Mask: 128}})

DMaxIPAddr is the max DIPaddr.

View Source 
var DMaxUUID = NewDUuid(DUuid{uuid.UUID{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}})

DMaxUUID is the max UUID.

View Source 
var DMinIPAddr = NewDIPAddr(DIPAddr{ipaddr.IPAddr{Family: ipaddr.IPv4family, Addr: dIPv4min, Mask: 0}})

DMinIPAddr is the min DIPAddr.

View Source 
var DMinUUID = NewDUuid(DUuid{uuid.UUID{}})

DMinUUID is the min UUID.

View Source 
var (

	// ErrAsOfSpecifiedWithReadWrite is returned when a statement attempts to set
	// a historical query to READ WRITE which conflicts with its implied READ ONLY
	// mode.
	ErrAsOfSpecifiedWithReadWrite = pgerror.New(pgcode.Syntax, "AS OF SYSTEM TIME specified with READ WRITE mode")
)
View Source 
var FunDefs map[string]*FunctionDefinition

FunDefs holds pre-allocated FunctionDefinition instances for every builtin function. Initialized by builtins.init().

View Source 
var IsolationLevelMap = map[string]IsolationLevel{
	"serializable": SerializableIsolation,
}

IsolationLevelMap is a map from string isolation level name to isolation level, in the lowercase format that set isolation_level supports.

View Source 
var JobCommandToStatement = map[JobCommand]string{
	PauseJob:  "PAUSE",
	CancelJob: "CANCEL",
	ResumeJob: "RESUME",
}

JobCommandToStatement translates a job command integer to a statement prefix.

View Source 
var ReturningNothingClause = &ReturningNothing{}

ReturningNothingClause is a shared instance to avoid unnecessary allocations.

View Source 
var UnaryOps = unaryOpFixups(map[UnaryOperator]unaryOpOverload{
	UnaryMinus: {
		&UnaryOp{
			Typ:        types.Int,
			ReturnType: types.Int,
			Fn: func(_ *EvalContext, d Datum) (Datum, error) {
				i := MustBeDInt(d)
				if i == math.MinInt64 {
					return nil, ErrIntOutOfRange
				}
				return NewDInt(-i), nil
			},
			Volatility: VolatilityImmutable,
		},
		&UnaryOp{
			Typ:        types.Float,
			ReturnType: types.Float,
			Fn: func(_ *EvalContext, d Datum) (Datum, error) {
				return NewDFloat(-*d.(*DFloat)), nil
			},
			Volatility: VolatilityImmutable,
		},
		&UnaryOp{
			Typ:        types.Decimal,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, d Datum) (Datum, error) {
				dec := &d.(*DDecimal).Decimal
				dd := &DDecimal{}
				dd.Decimal.Neg(dec)
				return dd, nil
			},
			Volatility: VolatilityImmutable,
		},
		&UnaryOp{
			Typ:        types.Interval,
			ReturnType: types.Interval,
			Fn: func(_ *EvalContext, d Datum) (Datum, error) {
				i := d.(*DInterval).Duration
				i.SetNanos(-i.Nanos())
				i.Days = -i.Days
				i.Months = -i.Months
				return &DInterval{Duration: i}, nil
			},
			Volatility: VolatilityImmutable,
		},
	},

	UnaryComplement: {
		&UnaryOp{
			Typ:        types.Int,
			ReturnType: types.Int,
			Fn: func(_ *EvalContext, d Datum) (Datum, error) {
				return NewDInt(^MustBeDInt(d)), nil
			},
			Volatility: VolatilityImmutable,
		},
		&UnaryOp{
			Typ:        types.VarBit,
			ReturnType: types.VarBit,
			Fn: func(_ *EvalContext, d Datum) (Datum, error) {
				p := MustBeDBitArray(d)
				return &DBitArray{BitArray: bitarray.Not(p.BitArray)}, nil
			},
			Volatility: VolatilityImmutable,
		},
		&UnaryOp{
			Typ:        types.INet,
			ReturnType: types.INet,
			Fn: func(_ *EvalContext, d Datum) (Datum, error) {
				ipAddr := MustBeDIPAddr(d).IPAddr
				return NewDIPAddr(DIPAddr{ipAddr.Complement()}), nil
			},
			Volatility: VolatilityImmutable,
		},
	},

	UnarySqrt: {
		&UnaryOp{
			Typ:        types.Float,
			ReturnType: types.Float,
			Fn: func(_ *EvalContext, d Datum) (Datum, error) {
				return Sqrt(float64(*d.(*DFloat)))
			},
			Volatility: VolatilityImmutable,
		},
		&UnaryOp{
			Typ:        types.Decimal,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, d Datum) (Datum, error) {
				dec := &d.(*DDecimal).Decimal
				return DecimalSqrt(dec)
			},
			Volatility: VolatilityImmutable,
		},
	},

	UnaryCbrt: {
		&UnaryOp{
			Typ:        types.Float,
			ReturnType: types.Float,
			Fn: func(_ *EvalContext, d Datum) (Datum, error) {
				return Cbrt(float64(*d.(*DFloat)))
			},
			Volatility: VolatilityImmutable,
		},
		&UnaryOp{
			Typ:        types.Decimal,
			ReturnType: types.Decimal,
			Fn: func(_ *EvalContext, d Datum) (Datum, error) {
				dec := &d.(*DDecimal).Decimal
				return DecimalCbrt(dec)
			},
			Volatility: VolatilityImmutable,
		},
	},
})

UnaryOps contains the unary operations indexed by operation type.

View Source 
var UnknownReturnType *types.T

UnknownReturnType is returned from ReturnTypers when the arguments provided are not sufficient to determine a return type. This is necessary for cases like overload resolution, where the argument types are not resolved yet so the type-level function will be called without argument types. If a ReturnTyper returns unknownReturnType, then the candidate function set cannot be refined. This means that only ReturnTypers that never return unknownReturnType, like those created with FixedReturnType, can help reduce overload ambiguity.

Functions

func AsJSON 

func AsJSON(d Datum, loc *time.Location) (json.JSON, error)

AsJSON converts a datum into our standard json representation.

func AsString 

func AsString(n NodeFormatter) string

AsString pretty prints a node to a string.

func AsStringWithFQNames 

func AsStringWithFQNames(n NodeFormatter, ann *Annotations) string

AsStringWithFQNames pretty prints a node to a string with the FmtAlwaysQualifyTableNames flag (which requires annotations).

func AsStringWithFlags 

func AsStringWithFlags(n NodeFormatter, fl FmtFlags) string

AsStringWithFlags pretty prints a node to a string given specific flags; only flags that don't require Annotations can be used.

func CanModifySchema 

func CanModifySchema(stmt Statement) bool

CanModifySchema returns true if the statement can modify the database schema.

func CanWriteData 

func CanWriteData(stmt Statement) bool

CanWriteData returns true if the statement can modify data.

func CheckIsWindowOrAgg 

func CheckIsWindowOrAgg(def *FunctionDefinition) error

CheckIsWindowOrAgg returns an error if the function definition is not a window function or an aggregate.

func CompareBools 

func CompareBools(d, v bool) int

CompareBools compares the input bools according to the SQL comparison rules.

func CompareDecimals 

func CompareDecimals(d *apd.Decimal, v *apd.Decimal) int

CompareDecimals compares 2 apd.Decimals according to the SQL comparison rules, making sure that NaNs sort first.

func ComputeColNameInternal 

func ComputeColNameInternal(sp sessiondata.SearchPath, target Expr) (int, string, error)

ComputeColNameInternal is the workhorse for GetRenderColName. The return value indicates the strength of the confidence in the result: 0 - no information 1 - second-best name choice 2 - good name choice

The algorithm is borrowed from FigureColnameInternal in PostgreSQL 10, to be found in src/backend/parser/parse_target.c.

func ContainsVars 

func ContainsVars(expr Expr) bool

ContainsVars returns true if the expression contains any variables. (variables = sub-expressions, placeholders, indexed vars, etc.)

func ConvertLikeToRegexp 

func ConvertLikeToRegexp(
	ctx *EvalContext, pattern string, caseInsensitive bool, escape rune,
) (*regexp.Regexp, error)

ConvertLikeToRegexp compiles the specified LIKE pattern as an equivalent regular expression.

func DatumToHLC 

func DatumToHLC(evalCtx *EvalContext, stmtTimestamp time.Time, d Datum) (hlc.Timestamp, error)

DatumToHLC performs the conversion from a Datum to an HLC timestamp.

func DatumTypeSize 

func DatumTypeSize(t *types.T) (size uintptr, isVarlen bool)

DatumTypeSize returns a lower bound on the total size of a Datum of the given type in bytes, including memory that is pointed at (even if shared between Datum instances) but excluding allocation overhead.

The second return value indicates whether data of this type have different sizes.

It holds for every Datum d that d.Size() >= DatumSize(d.ResolvedType())

func DecimalToHLC 

func DecimalToHLC(d *apd.Decimal) (hlc.Timestamp, error)

DecimalToHLC performs the conversion from an inputted DECIMAL datum for an AS OF SYSTEM TIME query to an HLC timestamp.

func ErrNameString 

func ErrNameString(s string) string

ErrNameString escapes an identifier stored a string to a SQL identifier suitable for printing in error messages.

func ErrNameStringP 

func ErrNameStringP(s *string) string

ErrNameStringP escapes an identifier stored a string to a SQL identifier suitable for printing in error messages, avoiding a heap allocation.

func ErrString 

func ErrString(n NodeFormatter) string

ErrString pretty prints a node to a string. Identifiers are not quoted.

func EvalAsOfTimestamp 

func EvalAsOfTimestamp(
	ctx context.Context, asOf AsOfClause, semaCtx *SemaContext, evalCtx *EvalContext,
) (tsss hlc.Timestamp, err error)

EvalAsOfTimestamp evaluates the timestamp argument to an AS OF SYSTEM TIME query.

func ExprDebugString 

func ExprDebugString(expr Expr) string

ExprDebugString generates a multi-line debug string with one node per line in Go format.

func FindEqualComparisonFunction 

func FindEqualComparisonFunction(
	leftType, rightType *types.T,
) (func(*EvalContext, Datum, Datum) (Datum, error), bool)

FindEqualComparisonFunction looks up an overload of the "=" operator for a given pair of input operand types.

func GetEnumComponentsFromPhysicalRep 

func GetEnumComponentsFromPhysicalRep(typ *types.T, rep []byte) ([]byte, string, error)

GetEnumComponentsFromPhysicalRep returns the physical and logical components for an enum of the requested type. It returns an error if it cannot find a matching physical representation.

func GetParamsAndReturnType 

func GetParamsAndReturnType(impl overloadImpl) (TypeList, ReturnTyper)

GetParamsAndReturnType gets the parameters and return type of an overloadImpl.

func GetRenderColName 

func GetRenderColName(searchPath sessiondata.SearchPath, target SelectExpr) (string, error)

GetRenderColName computes a name for a result column. A name specified with AS takes priority, otherwise a name is derived from the expression.

This function is meant to be used on untransformed syntax trees.

The algorithm is borrowed from FigureColName() in PostgreSQL 10, to be found in src/backend/parser/parse_target.c. We reuse this algorithm to provide names more compatible with PostgreSQL.

func GetStaticallyKnownType 

func GetStaticallyKnownType(ref ResolvableTypeReference) (typ *types.T, ok bool)

GetStaticallyKnownType possibly promotes a ResolvableTypeReference into a *types.T if the reference is a statically known type. It is only safe to access the returned type if ok is true.

func HasReturningClause 

func HasReturningClause(clause ReturningClause) bool

HasReturningClause determines if a ReturningClause is present, given a variant of the ReturningClause interface.

func IsConst 

func IsConst(evalCtx *EvalContext, expr TypedExpr) bool

IsConst returns whether the expression is constant. A constant expression does not contain variables, as defined by ContainsVars, nor impure functions.

func IsReferenceSerialType 

func IsReferenceSerialType(ref ResolvableTypeReference) bool

IsReferenceSerialType returns whether the input reference is a known serial type. It should only be used during parsing.

func IsStmtParallelized 

func IsStmtParallelized(stmt Statement) bool

IsStmtParallelized determines if a given statement's execution should be parallelized. This means that its results should be mocked out, and that it should be run asynchronously and in parallel with other statements that are independent.

func LimitDecimalWidth 

func LimitDecimalWidth(d *apd.Decimal, precision, scale int) error

LimitDecimalWidth limits d's precision (total number of digits) and scale (number of digits after the decimal point). Note that this any limiting will modify the decimal in-place.

func MockNameTypes 

func MockNameTypes(types map[string]*types.T) func()

MockNameTypes populates presetTypesForTesting for a test.

func MustBeStaticallyKnownType 

func MustBeStaticallyKnownType(ref ResolvableTypeReference) *types.T

MustBeStaticallyKnownType does the same thing as GetStaticallyKnownType but panics in the case that the reference is not statically known. This function is intended to be used in tests or in cases where it is not possible to have any unresolved type references.

func NameString 

func NameString(s string) string

NameString escapes an identifier stored in a string to a SQL identifier.

func NameStringP 

func NameStringP(s *string) string

NameStringP escapes an identifier stored in a heap string to a SQL identifier, avoiding a heap allocation.

func NewAggInAggError 

func NewAggInAggError() error

NewAggInAggError creates an error for the case when an aggregate function is contained within another aggregate function.

func NewCannotMixBitArraySizesError 

func NewCannotMixBitArraySizesError(op string) error

NewCannotMixBitArraySizesError creates an error for the case when a bitwise aggregate function is called on bit arrays with different sizes.

func NewInvalidFunctionUsageError 

func NewInvalidFunctionUsageError(class FunctionClass, context string) error

NewInvalidFunctionUsageError creates a rejection for a special function.

func NewInvalidNestedSRFError 

func NewInvalidNestedSRFError(context string) error

NewInvalidNestedSRFError creates a rejection for a nested SRF.

func NewTypeIsNotCompositeError 

func NewTypeIsNotCompositeError(resolvedType *types.T) error

NewTypeIsNotCompositeError generates an error suitable to report when a ColumnAccessExpr or TupleStar is applied to a non-composite type.

func Pretty 

func Pretty(stmt NodeFormatter) string

Pretty pretty prints stmt with default options.

func ProcessPlaceholderAnnotations 

func ProcessPlaceholderAnnotations(
	semaCtx *SemaContext, stmt Statement, typeHints PlaceholderTypes,
) error

ProcessPlaceholderAnnotations performs an order-independent global traversal of the provided Statement, annotating all placeholders with a type in either of the following situations:

  • the placeholder is the subject of an explicit type annotation in at least one of its occurrences. If it is subject to multiple explicit type annotations where the types are not all in agreement, or if the placeholder already has a type hint in the placeholder map which conflicts with the explicit type annotation type, an error will be thrown.

  • the placeholder is the subject to a cast of the same type in all occurrences of the placeholder. If the placeholder is subject to casts of multiple types, or if it has occurrences without a cast, no error will be thrown but the type will not be inferred. If the placeholder already has a type hint, that type will be kept regardless of any casts.

See docs/RFCS/20160203_typing.md for more details on placeholder typing (in particular section "First pass: placeholder annotations").

The typeHints slice contains the client-provided hints and is populated with any newly assigned types. It is assumed to be pre-sized to the number of placeholders in the statement and is populated accordingly.

TODO(nvanbenschoten): Can this visitor and map be preallocated (like normalizeVisitor)?

func ResolveExisting 

func ResolveExisting(
	ctx context.Context,
	u *UnresolvedObjectName,
	r ObjectNameExistingResolver,
	lookupFlags ObjectLookupFlags,
	curDb string,
	searchPath sessiondata.SearchPath,
) (bool, ObjectNamePrefix, NameResolutionResult, error)

ResolveExisting performs name resolution for an object name when the target object is expected to exist already. It does not mutate the input name. It additionally returns the resolved prefix qualification for the object. For example, if the unresolved name was "a.b" and the name was resolved to "a.public.b", the prefix "a.public" is returned.

func ResolveTarget 

func ResolveTarget(
	ctx context.Context,
	u *UnresolvedObjectName,
	r ObjectNameTargetResolver,
	curDb string,
	searchPath sessiondata.SearchPath,
) (found bool, namePrefix ObjectNamePrefix, scMeta SchemaMeta, err error)

ResolveTarget performs name resolution for an object name when the target object is not expected to exist already. It does not mutate the input name. It additionally returns the resolved prefix qualification for the object. For example, if the unresolved name was "a.b" and the name was resolved to "a.public.b", the prefix "a.public" is returned.

func ResolveType 

func ResolveType(
	ctx context.Context, ref ResolvableTypeReference, resolver TypeReferenceResolver,
) (*types.T, error)

ResolveType converts a ResolvableTypeReference into a *types.T.

func Serialize 

func Serialize(n NodeFormatter) string

Serialize pretty prints a node to a string using FmtSerializable; it is appropriate when we store expressions into strings that are stored on disk and may be later parsed back into expressions.

func SerializeForDisplay 

func SerializeForDisplay(n NodeFormatter) string

SerializeForDisplay pretty prints a node to a string using FmtParsable. It is appropriate when printing expressions that are visible to end users.

func SimilarEscape 

func SimilarEscape(pattern string) string

SimilarEscape converts a SQL:2008 regexp pattern to POSIX style, so it can be used by our regexp engine.

func SizeOfDecimal 

func SizeOfDecimal(d apd.Decimal) uintptr

SizeOfDecimal returns the size in bytes of an apd.Decimal.

func StmtDebugString 

func StmtDebugString(stmt Statement) string

StmtDebugString generates multi-line debug strings in Go format for the expressions that are part of the given statement.

func TimeFamilyPrecisionToRoundDuration 

func TimeFamilyPrecisionToRoundDuration(precision int32) time.Duration

TimeFamilyPrecisionToRoundDuration takes in a type's precision, and returns the duration to use to pass into time.Truncate to truncate to that duration. Panics if the precision is not supported.

func WalkExprConst 

func WalkExprConst(v Visitor, expr Expr)

WalkExprConst is a variant of WalkExpr for visitors that do not modify the expression.

func WindowModeName 

func WindowModeName(mode WindowFrameMode) string

WindowModeName returns the name of the window frame mode.

Types

type AggType 

type AggType int

AggType specifies the type of aggregation. 

const (

	// GeneralAgg is used for general-purpose aggregate functions.
	// array_agg(col1 ORDER BY col2)
	GeneralAgg AggType
	// OrderedSetAgg is used for ordered-set aggregate functions.
	// percentile_disc(fraction) WITHIN GROUP (ORDER BY col1)
	OrderedSetAgg
)

FuncExpr.AggType

type AggregateFunc 

type AggregateFunc interface {
	// Add accumulates the passed datums into the AggregateFunc.
	// Most implementations require one and only one firstArg argument.
	// If an aggregate function requires more than one argument,
	// all additional arguments (after firstArg) are passed in as a
	// variadic collection, otherArgs.
	// This interface (as opposed to `args ...Datum`) avoids unnecessary
	// allocation of otherArgs in the majority of cases.
	Add(_ context.Context, firstArg Datum, otherArgs ...Datum) error

	// Result returns the current value of the accumulation. This value
	// will be a deep copy of any AggregateFunc internal state, so that
	// it will not be mutated by additional calls to Add.
	Result() (Datum, error)

	// Reset resets the aggregate function which allows for reusing the same
	// instance for computation without the need to create a new instance.
	// Any memory is kept, if possible.
	Reset(context.Context)

	// Close closes out the AggregateFunc and allows it to release any memory it
	// requested during aggregation, and must be called upon completion of the
	// aggregation.
	Close(context.Context)

	// Size returns the size of the AggregateFunc implementation in bytes. It
	// does *not* account for additional memory used during accumulation.
	Size() int64
}

AggregateFunc accumulates the result of a function of a Datum.

type AliasClause 

type AliasClause struct {
	Alias Name
	Cols  NameList
}

AliasClause represents an alias, optionally with a column list: "AS name" or "AS name(col1, col2)".

func (*AliasClause) Format 

func (a *AliasClause) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type AliasedTableExpr 

type AliasedTableExpr struct {
	Expr       TableExpr
	IndexFlags *IndexFlags
	Ordinality bool
	Lateral    bool
	As         AliasClause
}

AliasedTableExpr represents a table expression coupled with an optional alias.

func (*AliasedTableExpr) Format 

func (node *AliasedTableExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AliasedTableExpr) String 

func (node *AliasedTableExpr) String() string

type AllColumnsSelector 

type AllColumnsSelector struct {
	// TableName corresponds to the table prefix, before the star.
	TableName *UnresolvedObjectName
}

AllColumnsSelector corresponds to a selection of all columns in a table when used in a SELECT clause. (e.g. `table.*`).

func (*AllColumnsSelector) Eval 

func (expr *AllColumnsSelector) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*AllColumnsSelector) Format 

func (a *AllColumnsSelector) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AllColumnsSelector) NormalizeVarName 

func (a *AllColumnsSelector) NormalizeVarName() (VarName, error)

NormalizeVarName implements the VarName interface.

func (*AllColumnsSelector) Resolve 

func (a *AllColumnsSelector) Resolve(
	ctx context.Context, r ColumnItemResolver,
) (srcName *TableName, srcMeta ColumnSourceMeta, err error)

Resolve performs name resolution for a qualified star using a resolver.

func (*AllColumnsSelector) ResolvedType 

func (*AllColumnsSelector) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*AllColumnsSelector) String 

func (a *AllColumnsSelector) String() string

func (*AllColumnsSelector) TypeCheck 

func (expr *AllColumnsSelector) TypeCheck(
	_ context.Context, _ *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*AllColumnsSelector) Variable 

func (a *AllColumnsSelector) Variable()

Variable implements the VariableExpr interface. Although, the AllColumnsSelector ought to be replaced to an IndexedVar before the points the VariableExpr interface is used.

func (*AllColumnsSelector) Walk 

func (expr *AllColumnsSelector) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type AllTablesSelector 

type AllTablesSelector struct {
	ObjectNamePrefix
}

AllTablesSelector corresponds to a selection of all tables in a database, e.g. when used with GRANT.

func (*AllTablesSelector) Format 

func (at *AllTablesSelector) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AllTablesSelector) NormalizeTablePattern 

func (at *AllTablesSelector) NormalizeTablePattern() (TablePattern, error)

NormalizeTablePattern implements the TablePattern interface.

func (*AllTablesSelector) String 

func (at *AllTablesSelector) String() string

type AlterIndex 

type AlterIndex struct {
	IfExists bool
	Index    TableIndexName
	Cmds     AlterIndexCmds
}

AlterIndex represents an ALTER INDEX statement.

func (*AlterIndex) Format 

func (node *AlterIndex) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AlterIndex) StatementTag 

func (*AlterIndex) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*AlterIndex) StatementType 

func (*AlterIndex) StatementType() StatementType

StatementType implements the Statement interface.

func (*AlterIndex) String 

func (n *AlterIndex) String() string

type AlterIndexCmd 

type AlterIndexCmd interface {
	NodeFormatter
	// contains filtered or unexported methods
}

AlterIndexCmd represents an index modification operation.

type AlterIndexCmds 

type AlterIndexCmds []AlterIndexCmd

AlterIndexCmds represents a list of index alterations.

func (*AlterIndexCmds) Format 

func (node *AlterIndexCmds) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type AlterIndexPartitionBy 

type AlterIndexPartitionBy struct {
	*PartitionBy
}

AlterIndexPartitionBy represents an ALTER INDEX PARTITION BY command.

func (*AlterIndexPartitionBy) Format 

func (node *AlterIndexPartitionBy) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type AlterRole 

type AlterRole struct {
	Name      Expr
	IfExists  bool
	IsRole    bool
	KVOptions KVOptions
}

AlterRole represents an ALTER ROLE statement.

func (*AlterRole) Format 

func (node *AlterRole) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AlterRole) StatementTag 

func (*AlterRole) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*AlterRole) StatementType 

func (*AlterRole) StatementType() StatementType

StatementType implements the Statement interface.

func (*AlterRole) String 

func (n *AlterRole) String() string

type AlterSequence 

type AlterSequence struct {
	IfExists bool
	Name     *UnresolvedObjectName
	Options  SequenceOptions
}

AlterSequence represents an ALTER SEQUENCE statement, except in the case of ALTER SEQUENCE <seqName> RENAME TO <newSeqName>, which is represented by a RenameTable node.

func (*AlterSequence) Format 

func (node *AlterSequence) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AlterSequence) StatementTag 

func (*AlterSequence) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*AlterSequence) StatementType 

func (*AlterSequence) StatementType() StatementType

StatementType implements the Statement interface.

func (*AlterSequence) String 

func (n *AlterSequence) String() string

type AlterTable 

type AlterTable struct {
	IfExists bool
	Table    *UnresolvedObjectName
	Cmds     AlterTableCmds
}

AlterTable represents an ALTER TABLE statement.

func (*AlterTable) Format 

func (node *AlterTable) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AlterTable) HoistAddColumnConstraints 

func (node *AlterTable) HoistAddColumnConstraints()

HoistAddColumnConstraints converts column constraints in ADD COLUMN commands, stored in node.Cmds, into top-level commands to add those constraints. Currently, this only applies to checks. For example, the ADD COLUMN in 

ALTER TABLE t ADD COLUMN a INT CHECK (a < 1)

is transformed into two commands, as in 

ALTER TABLE t ADD COLUMN a INT, ADD CONSTRAINT check_a CHECK (a < 1)

(with an auto-generated name).

Note that some SQL databases require that a constraint attached to a column to refer only to the column it is attached to. We follow Postgres' behavior, however, in omitting this restriction by blindly hoisting all column constraints. For example, the following statement is accepted in CockroachDB and Postgres, but not necessarily other SQL databases: 

ALTER TABLE t ADD COLUMN a INT CHECK (a < b)

func (*AlterTable) StatementTag 

func (*AlterTable) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*AlterTable) StatementType 

func (*AlterTable) StatementType() StatementType

StatementType implements the Statement interface.

func (*AlterTable) String 

func (n *AlterTable) String() string

type AlterTableAddColumn 

type AlterTableAddColumn struct {
	IfNotExists bool
	ColumnDef   *ColumnTableDef
}

AlterTableAddColumn represents an ADD COLUMN command.

func (*AlterTableAddColumn) Format 

func (node *AlterTableAddColumn) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AlterTableAddColumn) String 

func (n *AlterTableAddColumn) String() string

func (*AlterTableAddColumn) TelemetryCounter 

func (node *AlterTableAddColumn) TelemetryCounter() telemetry.Counter

TelemetryCounter implements the AlterTableCmd interface.

type AlterTableAddConstraint 

type AlterTableAddConstraint struct {
	ConstraintDef      ConstraintTableDef
	ValidationBehavior ValidationBehavior
}

AlterTableAddConstraint represents an ADD CONSTRAINT command.

func (*AlterTableAddConstraint) Format 

func (node *AlterTableAddConstraint) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AlterTableAddConstraint) String 

func (n *AlterTableAddConstraint) String() string

func (*AlterTableAddConstraint) TelemetryCounter 

func (node *AlterTableAddConstraint) TelemetryCounter() telemetry.Counter

TelemetryCounter implements the AlterTableCmd interface.

type AlterTableAlterColumnType 

type AlterTableAlterColumnType struct {
	Collation string
	Column    Name
	ToType    ResolvableTypeReference
	Using     Expr
}

AlterTableAlterColumnType represents an ALTER TABLE ALTER COLUMN TYPE command.

func (*AlterTableAlterColumnType) Format 

func (node *AlterTableAlterColumnType) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AlterTableAlterColumnType) GetColumn 

func (node *AlterTableAlterColumnType) GetColumn() Name

GetColumn implements the ColumnMutationCmd interface.

func (*AlterTableAlterColumnType) String 

func (n *AlterTableAlterColumnType) String() string

func (*AlterTableAlterColumnType) TelemetryCounter 

func (node *AlterTableAlterColumnType) TelemetryCounter() telemetry.Counter

TelemetryCounter implements the AlterTableCmd interface.

type AlterTableAlterPrimaryKey 

type AlterTableAlterPrimaryKey struct {
	Columns    IndexElemList
	Interleave *InterleaveDef
	Sharded    *ShardedIndexDef
}

AlterTableAlterPrimaryKey represents an ALTER TABLE ALTER PRIMARY KEY command.

func (*AlterTableAlterPrimaryKey) Format 

func (node *AlterTableAlterPrimaryKey) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AlterTableAlterPrimaryKey) TelemetryCounter 

func (node *AlterTableAlterPrimaryKey) TelemetryCounter() telemetry.Counter

TelemetryCounter implements the AlterTableCmd interface.

type AlterTableCmd 

type AlterTableCmd interface {
	NodeFormatter
	// TelemetryCounter returns the telemetry counter to increment
	// when this command is used.
	TelemetryCounter() telemetry.Counter
	// contains filtered or unexported methods
}

AlterTableCmd represents a table modification operation.

type AlterTableCmds 

type AlterTableCmds []AlterTableCmd

AlterTableCmds represents a list of table alterations.

func (*AlterTableCmds) Format 

func (node *AlterTableCmds) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AlterTableCmds) String 

func (n *AlterTableCmds) String() string

type AlterTableDropColumn 

type AlterTableDropColumn struct {
	IfExists     bool
	Column       Name
	DropBehavior DropBehavior
}

AlterTableDropColumn represents a DROP COLUMN command.

func (*AlterTableDropColumn) Format 

func (node *AlterTableDropColumn) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AlterTableDropColumn) String 

func (n *AlterTableDropColumn) String() string

func (*AlterTableDropColumn) TelemetryCounter 

func (node *AlterTableDropColumn) TelemetryCounter() telemetry.Counter

TelemetryCounter implements the AlterTableCmd interface.

type AlterTableDropConstraint 

type AlterTableDropConstraint struct {
	IfExists     bool
	Constraint   Name
	DropBehavior DropBehavior
}

AlterTableDropConstraint represents a DROP CONSTRAINT command.

func (*AlterTableDropConstraint) Format 

func (node *AlterTableDropConstraint) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AlterTableDropConstraint) String 

func (n *AlterTableDropConstraint) String() string

func (*AlterTableDropConstraint) TelemetryCounter 

func (node *AlterTableDropConstraint) TelemetryCounter() telemetry.Counter

TelemetryCounter implements the AlterTableCmd interface.

type AlterTableDropNotNull 

type AlterTableDropNotNull struct {
	Column Name
}

AlterTableDropNotNull represents an ALTER COLUMN DROP NOT NULL command.

func (*AlterTableDropNotNull) Format 

func (node *AlterTableDropNotNull) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AlterTableDropNotNull) GetColumn 

func (node *AlterTableDropNotNull) GetColumn() Name

GetColumn implements the ColumnMutationCmd interface.

func (*AlterTableDropNotNull) String 

func (n *AlterTableDropNotNull) String() string

func (*AlterTableDropNotNull) TelemetryCounter 

func (node *AlterTableDropNotNull) TelemetryCounter() telemetry.Counter

TelemetryCounter implements the AlterTableCmd interface.

type AlterTableDropStored 

type AlterTableDropStored struct {
	Column Name
}

AlterTableDropStored represents an ALTER COLUMN DROP STORED command to remove the computed-ness from a column.

func (*AlterTableDropStored) Format 

func (node *AlterTableDropStored) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AlterTableDropStored) GetColumn 

func (node *AlterTableDropStored) GetColumn() Name

GetColumn implemnets the ColumnMutationCmd interface.

func (*AlterTableDropStored) String 

func (n *AlterTableDropStored) String() string

func (*AlterTableDropStored) TelemetryCounter 

func (node *AlterTableDropStored) TelemetryCounter() telemetry.Counter

TelemetryCounter implements the AlterTableCmd interface.

type AlterTableInjectStats 

type AlterTableInjectStats struct {
	Stats Expr
}

AlterTableInjectStats represents an ALTER TABLE INJECT STATISTICS statement.

func (*AlterTableInjectStats) Format 

func (node *AlterTableInjectStats) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AlterTableInjectStats) TelemetryCounter 

func (node *AlterTableInjectStats) TelemetryCounter() telemetry.Counter

TelemetryCounter implements the AlterTableCmd interface.

type AlterTablePartitionBy 

type AlterTablePartitionBy struct {
	*PartitionBy
}

AlterTablePartitionBy represents an ALTER TABLE PARTITION BY command.

func (*AlterTablePartitionBy) Format 

func (node *AlterTablePartitionBy) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AlterTablePartitionBy) TelemetryCounter 

func (node *AlterTablePartitionBy) TelemetryCounter() telemetry.Counter

TelemetryCounter implements the AlterTableCmd interface.

type AlterTableRenameColumn 

type AlterTableRenameColumn struct {
	Column  Name
	NewName Name
}

AlterTableRenameColumn represents an ALTER TABLE RENAME [COLUMN] command.

func (*AlterTableRenameColumn) Format 

func (node *AlterTableRenameColumn) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AlterTableRenameColumn) TelemetryCounter 

func (node *AlterTableRenameColumn) TelemetryCounter() telemetry.Counter

TelemetryCounter implements the AlterTableCmd interface.

type AlterTableRenameConstraint 

type AlterTableRenameConstraint struct {
	Constraint Name
	NewName    Name
}

AlterTableRenameConstraint represents an ALTER TABLE RENAME CONSTRAINT command.

func (*AlterTableRenameConstraint) Format 

func (node *AlterTableRenameConstraint) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AlterTableRenameConstraint) TelemetryCounter 

func (node *AlterTableRenameConstraint) TelemetryCounter() telemetry.Counter

TelemetryCounter implements the AlterTableCmd interface.

type AlterTableSetAudit 

type AlterTableSetAudit struct {
	Mode AuditMode
}

AlterTableSetAudit represents an ALTER TABLE AUDIT SET statement.

func (*AlterTableSetAudit) Format 

func (node *AlterTableSetAudit) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AlterTableSetAudit) TelemetryCounter 

func (node *AlterTableSetAudit) TelemetryCounter() telemetry.Counter

TelemetryCounter implements the AlterTableCmd interface.

type AlterTableSetDefault 

type AlterTableSetDefault struct {
	Column  Name
	Default Expr
}

AlterTableSetDefault represents an ALTER COLUMN SET DEFAULT or DROP DEFAULT command.

func (*AlterTableSetDefault) Format 

func (node *AlterTableSetDefault) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AlterTableSetDefault) GetColumn 

func (node *AlterTableSetDefault) GetColumn() Name

GetColumn implements the ColumnMutationCmd interface.

func (*AlterTableSetDefault) String 

func (n *AlterTableSetDefault) String() string

func (*AlterTableSetDefault) TelemetryCounter 

func (node *AlterTableSetDefault) TelemetryCounter() telemetry.Counter

TelemetryCounter implements the AlterTableCmd interface.

type AlterTableSetNotNull 

type AlterTableSetNotNull struct {
	Column Name
}

AlterTableSetNotNull represents an ALTER COLUMN SET NOT NULL command.

func (*AlterTableSetNotNull) Format 

func (node *AlterTableSetNotNull) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AlterTableSetNotNull) GetColumn 

func (node *AlterTableSetNotNull) GetColumn() Name

GetColumn implements the ColumnMutationCmd interface.

func (*AlterTableSetNotNull) String 

func (n *AlterTableSetNotNull) String() string

func (*AlterTableSetNotNull) TelemetryCounter 

func (node *AlterTableSetNotNull) TelemetryCounter() telemetry.Counter

TelemetryCounter implements the AlterTableCmd interface.

type AlterTableValidateConstraint 

type AlterTableValidateConstraint struct {
	Constraint Name
}

AlterTableValidateConstraint represents a VALIDATE CONSTRAINT command.

func (*AlterTableValidateConstraint) Format 

func (node *AlterTableValidateConstraint) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AlterTableValidateConstraint) TelemetryCounter 

func (node *AlterTableValidateConstraint) TelemetryCounter() telemetry.Counter

TelemetryCounter implements the AlterTableCmd interface.

type AlterType 

type AlterType struct {
	Type *UnresolvedObjectName
	Cmd  AlterTypeCmd
}

AlterType represents an ALTER TYPE statement.

func (*AlterType) Format 

func (node *AlterType) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AlterType) StatementTag 

func (*AlterType) StatementTag() string

StatementTag implements the Statement interface.

func (*AlterType) StatementType 

func (*AlterType) StatementType() StatementType

StatementType implements the Statement interface.

func (*AlterType) String 

func (n *AlterType) String() string

type AlterTypeAddValue 

type AlterTypeAddValue struct {
	NewVal      string
	IfNotExists bool
	Placement   *AlterTypeAddValuePlacement
}

AlterTypeAddValue represents an ALTER TYPE ADD VALUE command.

func (*AlterTypeAddValue) Format 

func (node *AlterTypeAddValue) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type AlterTypeAddValuePlacement 

type AlterTypeAddValuePlacement struct {
	Before      bool
	ExistingVal string
}

AlterTypeAddValuePlacement represents the placement clause for an ALTER TYPE ADD VALUE command ([BEFORE | AFTER] value).

type AlterTypeCmd 

type AlterTypeCmd interface {
	NodeFormatter
	// contains filtered or unexported methods
}

AlterTypeCmd represents a type modification operation.

type AlterTypeRename 

type AlterTypeRename struct {
	NewName string
}

AlterTypeRename represents an ALTER TYPE RENAME command.

func (*AlterTypeRename) Format 

func (node *AlterTypeRename) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type AlterTypeRenameValue 

type AlterTypeRenameValue struct {
	OldVal string
	NewVal string
}

AlterTypeRenameValue represents an ALTER TYPE RENAME VALUE command.

func (*AlterTypeRenameValue) Format 

func (node *AlterTypeRenameValue) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type AlterTypeSetSchema 

type AlterTypeSetSchema struct {
	Schema string
}

AlterTypeSetSchema represents an ALTER TYPE SET SCHEMA command.

func (*AlterTypeSetSchema) Format 

func (node *AlterTypeSetSchema) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type Analyze 

type Analyze struct {
	Table TableExpr
}

Analyze represents an ANALYZE statement.

func (*Analyze) Format 

func (node *Analyze) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Analyze) StatementTag 

func (*Analyze) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Analyze) StatementType 

func (*Analyze) StatementType() StatementType

StatementType implements the Statement interface.

func (*Analyze) String 

func (n *Analyze) String() string

type AndExpr 

type AndExpr struct {
	Left, Right Expr
	// contains filtered or unexported fields
}

AndExpr represents an AND expression.

func NewTypedAndExpr 

func NewTypedAndExpr(left, right TypedExpr) *AndExpr

NewTypedAndExpr returns a new AndExpr that is verified to be well-typed.

func (*AndExpr) Eval 

func (expr *AndExpr) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*AndExpr) Format 

func (node *AndExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (AndExpr) ResolvedType 

func (ta AndExpr) ResolvedType() *types.T

func (*AndExpr) String 

func (node *AndExpr) String() string

func (*AndExpr) TypeCheck 

func (expr *AndExpr) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*AndExpr) TypedLeft 

func (node *AndExpr) TypedLeft() TypedExpr

TypedLeft returns the AndExpr's left expression as a TypedExpr.

func (*AndExpr) TypedRight 

func (node *AndExpr) TypedRight() TypedExpr

TypedRight returns the AndExpr's right expression as a TypedExpr.

func (*AndExpr) Walk 

func (expr *AndExpr) Walk(v Visitor) Expr

Walk implements the Expr interface.

type AnnotateTypeExpr 

type AnnotateTypeExpr struct {
	Expr Expr
	Type ResolvableTypeReference

	SyntaxMode annotateSyntaxMode
}

AnnotateTypeExpr represents a ANNOTATE_TYPE(expr, type) expression.

func (*AnnotateTypeExpr) Format 

func (node *AnnotateTypeExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*AnnotateTypeExpr) String 

func (node *AnnotateTypeExpr) String() string

func (*AnnotateTypeExpr) TypeCheck 

func (expr *AnnotateTypeExpr) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*AnnotateTypeExpr) TypedInnerExpr 

func (node *AnnotateTypeExpr) TypedInnerExpr() TypedExpr

TypedInnerExpr returns the AnnotateTypeExpr's inner expression as a TypedExpr.

func (*AnnotateTypeExpr) Walk 

func (expr *AnnotateTypeExpr) Walk(v Visitor) Expr

Walk implements the Expr interface.

type AnnotatedNode 

type AnnotatedNode struct {
	AnnIdx AnnotationIdx
}

AnnotatedNode is embedded in AST nodes that have an annotation.

func (AnnotatedNode) GetAnnotation 

func (n AnnotatedNode) GetAnnotation(ann *Annotations) interface{}

GetAnnotation retrieves the annotation associated with this node.

func (AnnotatedNode) SetAnnotation 

func (n AnnotatedNode) SetAnnotation(ann *Annotations, annotation interface{})

SetAnnotation sets the annotation associated with this node.

type AnnotationIdx 

type AnnotationIdx int32

AnnotationIdx is the 1-based index of an annotation. AST nodes that can be annotated store such an index (unique within that AST). 

const NoAnnotation AnnotationIdx = 0

NoAnnotation is the uninitialized annotation index.

type Annotations 

type Annotations []interface{}

Annotations is a container for AST annotations.

func MakeAnnotations 

func MakeAnnotations(numAnnotations AnnotationIdx) Annotations

MakeAnnotations allocates an annotations container of the given size.

func (*Annotations) Get 

func (a *Annotations) Get(idx AnnotationIdx) interface{}

Get an annotation from the container.

func (*Annotations) Set 

func (a *Annotations) Set(idx AnnotationIdx, annotation interface{})

Set an annotation in the container.

type ArgTypes 

type ArgTypes []struct {
	Name string
	Typ  *types.T
}

ArgTypes is very similar to ArgTypes except it allows keeping a string name for each argument as well and using those when printing the human-readable signature.

func (ArgTypes) GetAt 

func (a ArgTypes) GetAt(i int) *types.T

GetAt is part of the TypeList interface.

func (ArgTypes) Length 

func (a ArgTypes) Length() int

Length is part of the TypeList interface.

func (ArgTypes) Match 

func (a ArgTypes) Match(types []*types.T) bool

Match is part of the TypeList interface.

func (ArgTypes) MatchAt 

func (a ArgTypes) MatchAt(typ *types.T, i int) bool

MatchAt is part of the TypeList interface.

func (ArgTypes) MatchLen 

func (a ArgTypes) MatchLen(l int) bool

MatchLen is part of the TypeList interface.

func (ArgTypes) String 

func (a ArgTypes) String() string

func (ArgTypes) Types 

func (a ArgTypes) Types() []*types.T

Types is part of the TypeList interface.

type Array 

type Array struct {
	Exprs Exprs
	// contains filtered or unexported fields
}

Array represents an array constructor.

func NewTypedArray 

func NewTypedArray(typedExprs TypedExprs, typ *types.T) *Array

NewTypedArray returns an Array that is well-typed.

func (*Array) Eval 

func (t *Array) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*Array) Format 

func (node *Array) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (Array) ResolvedType 

func (ta Array) ResolvedType() *types.T

func (*Array) String 

func (node *Array) String() string

func (*Array) TypeCheck 

func (expr *Array) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*Array) Walk 

func (expr *Array) Walk(v Visitor) Expr

Walk implements the Expr interface.

type ArrayFlatten 

type ArrayFlatten struct {
	Subquery Expr
	// contains filtered or unexported fields
}

ArrayFlatten represents a subquery array constructor.

func NewTypedArrayFlattenExpr 

func NewTypedArrayFlattenExpr(input Expr) *ArrayFlatten

NewTypedArrayFlattenExpr returns a new ArrayFlattenExpr that is verified to be well-typed.

func (*ArrayFlatten) Eval 

func (t *ArrayFlatten) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*ArrayFlatten) Format 

func (node *ArrayFlatten) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (ArrayFlatten) ResolvedType 

func (ta ArrayFlatten) ResolvedType() *types.T

func (*ArrayFlatten) String 

func (node *ArrayFlatten) String() string

func (*ArrayFlatten) TypeCheck 

func (expr *ArrayFlatten) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*ArrayFlatten) Walk 

func (expr *ArrayFlatten) Walk(v Visitor) Expr

Walk implements the Expr interface.

type ArraySubscript 

type ArraySubscript struct {
	Begin Expr
	End   Expr
	Slice bool
}

ArraySubscript corresponds to the syntax `<name>[ ... ]`.

func (*ArraySubscript) Format 

func (a *ArraySubscript) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type ArraySubscripts 

type ArraySubscripts []*ArraySubscript

ArraySubscripts represents a sequence of one or more array subscripts.

func (*ArraySubscripts) Format 

func (a *ArraySubscripts) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type ArrayTypeReference 

type ArrayTypeReference struct {
	ElementType ResolvableTypeReference
}

ArrayTypeReference represents an array of possibly unknown type references.

func (*ArrayTypeReference) SQLString 

func (node *ArrayTypeReference) SQLString() string

SQLString implements the ResolvableTypeReference interface.

type AsOfClause 

type AsOfClause struct {
	Expr Expr
}

AsOfClause represents an as of time.

func (*AsOfClause) Format 

func (a *AsOfClause) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type AuditMode 

type AuditMode int

AuditMode represents a table audit mode 

const (
	// AuditModeDisable is the default mode - no audit.
	AuditModeDisable AuditMode = iota
	// AuditModeReadWrite enables audit on read or write statements.
	AuditModeReadWrite
)

func (AuditMode) String 

func (m AuditMode) String() string

func (AuditMode) TelemetryName 

func (m AuditMode) TelemetryName() string

TelemetryName returns a friendly string for use in telemetry that represents the AuditMode.

type Backup 

type Backup struct {
	Targets            TargetList
	DescriptorCoverage DescriptorCoverage
	To                 PartitionedBackup
	IncrementalFrom    Exprs
	AsOf               AsOfClause
	Options            BackupOptions
}

Backup represents a BACKUP statement.

func (*Backup) Format 

func (node *Backup) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Backup) StatementTag 

func (*Backup) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Backup) StatementType 

func (*Backup) StatementType() StatementType

StatementType implements the Statement interface.

func (*Backup) String 

func (n *Backup) String() string

type BackupDetails 

type BackupDetails int

BackupDetails represents the type of details to display for a SHOW BACKUP statement. 

const (
	// BackupDefaultDetails identifies a bare SHOW BACKUP statement.
	BackupDefaultDetails BackupDetails = iota
	// BackupRangeDetails identifies a SHOW BACKUP RANGES statement.
	BackupRangeDetails
	// BackupFileDetails identifies a SHOW BACKUP FILES statement.
	BackupFileDetails
)

type BackupOptions 

type BackupOptions struct {
	CaptureRevisionHistory bool
	EncryptionPassphrase   Expr
	Detached               bool
}

BackupOptions describes options for the BACKUP execution.

func (*BackupOptions) CombineWith 

func (o *BackupOptions) CombineWith(other *BackupOptions) error

CombineWith merges other backup options into this backup options struct. An error is returned if the same option merged multiple times.

func (*BackupOptions) Format 

func (o *BackupOptions) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface

func (BackupOptions) IsDefault 

func (o BackupOptions) IsDefault() bool

IsDefault returns true if this backup options struct has default value.

type BeginTransaction 

type BeginTransaction struct {
	Modes TransactionModes
}

BeginTransaction represents a BEGIN statement

func (*BeginTransaction) Format 

func (node *BeginTransaction) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*BeginTransaction) StatementTag 

func (*BeginTransaction) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*BeginTransaction) StatementType 

func (*BeginTransaction) StatementType() StatementType

StatementType implements the Statement interface.

func (*BeginTransaction) String 

func (n *BeginTransaction) String() string

type BinOp 

type BinOp struct {
	LeftType     *types.T
	RightType    *types.T
	ReturnType   *types.T
	NullableArgs bool
	Fn           func(*EvalContext, Datum, Datum) (Datum, error)
	Volatility   Volatility
	// contains filtered or unexported fields
}

BinOp is a binary operator.

type BinaryExpr 

type BinaryExpr struct {
	Operator    BinaryOperator
	Left, Right Expr

	Fn *BinOp
	// contains filtered or unexported fields
}

BinaryExpr represents a binary value expression.

func NewTypedBinaryExpr 

func NewTypedBinaryExpr(op BinaryOperator, left, right TypedExpr, typ *types.T) *BinaryExpr

NewTypedBinaryExpr returns a new BinaryExpr that is well-typed.

func (*BinaryExpr) Eval 

func (expr *BinaryExpr) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*BinaryExpr) Format 

func (node *BinaryExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*BinaryExpr) ResolvedBinOp 

func (node *BinaryExpr) ResolvedBinOp() *BinOp

ResolvedBinOp returns the resolved binary op overload; can only be called after Resolve (which happens during TypeCheck).

func (BinaryExpr) ResolvedType 

func (ta BinaryExpr) ResolvedType() *types.T

func (*BinaryExpr) String 

func (node *BinaryExpr) String() string

func (*BinaryExpr) TypeCheck 

func (expr *BinaryExpr) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*BinaryExpr) TypedLeft 

func (node *BinaryExpr) TypedLeft() TypedExpr

TypedLeft returns the BinaryExpr's left expression as a TypedExpr.

func (*BinaryExpr) TypedRight 

func (node *BinaryExpr) TypedRight() TypedExpr

TypedRight returns the BinaryExpr's right expression as a TypedExpr.

func (*BinaryExpr) Walk 

func (expr *BinaryExpr) Walk(v Visitor) Expr

Walk implements the Expr interface.

type BinaryOperator 

type BinaryOperator int

BinaryOperator represents a binary operator. 

const (
	Bitand BinaryOperator = iota
	Bitor
	Bitxor
	Plus
	Minus
	Mult
	Div
	FloorDiv
	Mod
	Pow
	Concat
	LShift
	RShift
	JSONFetchVal
	JSONFetchText
	JSONFetchValPath
	JSONFetchTextPath

	NumBinaryOperators
)

BinaryExpr.Operator

func (BinaryOperator) String 

func (i BinaryOperator) String() string

type CCLOnlyStatement 

type CCLOnlyStatement interface {
	// contains filtered or unexported methods
}

CCLOnlyStatement is a marker interface for statements that require a CCL binary for successful planning or execution. It is used to enhance error messages when attempting to use these statements in non-CCL binaries.

type CTE 

type CTE struct {
	Name AliasClause
	Mtr  MaterializeClause
	Stmt Statement
}

CTE represents a common table expression inside of a WITH clause.

type CallbackValueGenerator 

type CallbackValueGenerator struct {
	// contains filtered or unexported fields
}

CallbackValueGenerator is a ValueGenerator that calls a supplied callback for producing the values. To be used with EvalContextTestingKnobs.CallbackGenerators.

func NewCallbackValueGenerator 

func NewCallbackValueGenerator(
	cb func(ctx context.Context, prev int) (int, error),
) *CallbackValueGenerator

NewCallbackValueGenerator creates a new CallbackValueGenerator.

func (*CallbackValueGenerator) Close 

func (c *CallbackValueGenerator) Close()

Close is part of the ValueGenerator interface.

func (*CallbackValueGenerator) Next 

func (c *CallbackValueGenerator) Next(ctx context.Context) (bool, error)

Next is part of the ValueGenerator interface.

func (*CallbackValueGenerator) ResolvedType 

func (c *CallbackValueGenerator) ResolvedType() *types.T

ResolvedType is part of the ValueGenerator interface.

func (*CallbackValueGenerator) Values 

func (c *CallbackValueGenerator) Values() (Datums, error)

Values is part of the ValueGenerator interface.

type CancelQueries 

type CancelQueries struct {
	Queries  *Select
	IfExists bool
}

CancelQueries represents a CANCEL QUERIES statement.

func (*CancelQueries) Format 

func (node *CancelQueries) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*CancelQueries) StatementTag 

func (*CancelQueries) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*CancelQueries) StatementType 

func (*CancelQueries) StatementType() StatementType

StatementType implements the Statement interface.

func (*CancelQueries) String 

func (n *CancelQueries) String() string

type CancelSessions 

type CancelSessions struct {
	Sessions *Select
	IfExists bool
}

CancelSessions represents a CANCEL SESSIONS statement.

func (*CancelSessions) Format 

func (node *CancelSessions) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*CancelSessions) StatementTag 

func (*CancelSessions) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*CancelSessions) StatementType 

func (*CancelSessions) StatementType() StatementType

StatementType implements the Statement interface.

func (*CancelSessions) String 

func (n *CancelSessions) String() string

type CannedOptPlan 

type CannedOptPlan struct {
	Plan string
}

CannedOptPlan is used as the AST for a PREPARE .. AS OPT PLAN statement. This is a testing facility that allows execution (and benchmarking) of specific plans. See exprgen package for more information on the syntax.

func (*CannedOptPlan) Format 

func (node *CannedOptPlan) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*CannedOptPlan) StatementTag 

func (*CannedOptPlan) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*CannedOptPlan) StatementType 

func (*CannedOptPlan) StatementType() StatementType

StatementType implements the Statement interface.

func (*CannedOptPlan) String 

func (n *CannedOptPlan) String() string

type CaseExpr 

type CaseExpr struct {
	Expr  Expr
	Whens []*When
	Else  Expr
	// contains filtered or unexported fields
}

CaseExpr represents a CASE expression.

func NewTypedCaseExpr 

func NewTypedCaseExpr(
	expr TypedExpr, whens []*When, elseStmt TypedExpr, typ *types.T,
) (*CaseExpr, error)

NewTypedCaseExpr returns a new CaseExpr that is verified to be well-typed.

func (*CaseExpr) Eval 

func (expr *CaseExpr) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*CaseExpr) Format 

func (node *CaseExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (CaseExpr) ResolvedType 

func (ta CaseExpr) ResolvedType() *types.T

func (*CaseExpr) String 

func (node *CaseExpr) String() string

func (*CaseExpr) TypeCheck 

func (expr *CaseExpr) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*CaseExpr) Walk 

func (expr *CaseExpr) Walk(v Visitor) Expr

Walk implements the Expr interface.

type CastExpr 

type CastExpr struct {
	Expr Expr
	Type ResolvableTypeReference

	SyntaxMode castSyntaxMode
	// contains filtered or unexported fields
}

CastExpr represents a CAST(expr AS type) expression.

func NewTypedCastExpr 

func NewTypedCastExpr(expr TypedExpr, typ *types.T) *CastExpr

NewTypedCastExpr returns a new CastExpr that is verified to be well-typed.

func (*CastExpr) Eval 

func (expr *CastExpr) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*CastExpr) Format 

func (node *CastExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (CastExpr) ResolvedType 

func (ta CastExpr) ResolvedType() *types.T

func (*CastExpr) String 

func (node *CastExpr) String() string

func (*CastExpr) TypeCheck 

func (expr *CastExpr) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, _ *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*CastExpr) Walk 

func (expr *CastExpr) Walk(v Visitor) Expr

Walk implements the Expr interface.

type CheckConstraintTableDef 

type CheckConstraintTableDef struct {
	Name   Name
	Expr   Expr
	Hidden bool
}

CheckConstraintTableDef represents a check constraint within a CREATE TABLE statement.

func (*CheckConstraintTableDef) Format 

func (node *CheckConstraintTableDef) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*CheckConstraintTableDef) SetName 

func (node *CheckConstraintTableDef) SetName(name Name)

SetName implements the ConstraintTableDef interface.

type ClientNoticeSender 

type ClientNoticeSender interface {
	// SendClientNotice sends a notice out-of-band to the client.
	SendClientNotice(ctx context.Context, notice error)
}

ClientNoticeSender is a limited interface to send notices to the client.

TODO(knz): as of this writing, the implementations of this interface only work on the gateway node (i.e. not from distributed processors).

type CmpOp 

type CmpOp struct {
	LeftType  *types.T
	RightType *types.T

	// If NullableArgs is false, the operator returns NULL
	// whenever either argument is NULL.
	NullableArgs bool

	// Datum return type is a union between *DBool and dNull.
	Fn func(*EvalContext, Datum, Datum) (Datum, error)

	Volatility Volatility
	// contains filtered or unexported fields
}

CmpOp is a comparison operator.

type CoalesceExpr 

type CoalesceExpr struct {
	Name  string
	Exprs Exprs
	// contains filtered or unexported fields
}

CoalesceExpr represents a COALESCE or IFNULL expression.

func NewTypedCoalesceExpr 

func NewTypedCoalesceExpr(typedExprs TypedExprs, typ *types.T) *CoalesceExpr

NewTypedCoalesceExpr returns a CoalesceExpr that is well-typed.

func (*CoalesceExpr) Eval 

func (expr *CoalesceExpr) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*CoalesceExpr) Format 

func (node *CoalesceExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (CoalesceExpr) ResolvedType 

func (ta CoalesceExpr) ResolvedType() *types.T

func (*CoalesceExpr) String 

func (node *CoalesceExpr) String() string

func (*CoalesceExpr) TypeCheck 

func (expr *CoalesceExpr) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*CoalesceExpr) TypedExprAt 

func (node *CoalesceExpr) TypedExprAt(idx int) TypedExpr

TypedExprAt returns the expression at the specified index as a TypedExpr.

func (*CoalesceExpr) Walk 

func (expr *CoalesceExpr) Walk(v Visitor) Expr

Walk implements the Expr interface.

type CollateExpr 

type CollateExpr struct {
	Expr   Expr
	Locale string
	// contains filtered or unexported fields
}

CollateExpr represents an (expr COLLATE locale) expression.

func NewTypedCollateExpr 

func NewTypedCollateExpr(expr TypedExpr, locale string) *CollateExpr

NewTypedCollateExpr returns a new CollateExpr that is verified to be well-typed.

func (*CollateExpr) Eval 

func (expr *CollateExpr) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*CollateExpr) Format 

func (node *CollateExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (CollateExpr) ResolvedType 

func (ta CollateExpr) ResolvedType() *types.T

func (*CollateExpr) String 

func (node *CollateExpr) String() string

func (*CollateExpr) TypeCheck 

func (expr *CollateExpr) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*CollateExpr) Walk 

func (expr *CollateExpr) Walk(v Visitor) Expr

Walk implements the Expr interface.

type CollationEnvironment 

type CollationEnvironment struct {
	// contains filtered or unexported fields
}

CollationEnvironment stores the state needed by NewDCollatedString to construct collation keys efficiently.

type ColumnAccessExpr 

type ColumnAccessExpr struct {
	Expr Expr

	// ByIndex, if set, indicates that the access is using a numeric
	// column reference and ColIndex below is already set.
	ByIndex bool

	// ColName is the name of the column to access. Empty if ByIndex is
	// set.
	ColName string

	// ColIndex indicates the index of the column in the tuple. This is
	// either:
	// - set during type checking based on the label in ColName if
	//   ByIndex is false,
	// - or checked for validity during type checking if ByIndex is true.
	// The first column in the tuple is at index 0. The input
	// syntax (E).@N populates N-1 in this field.
	ColIndex int
	// contains filtered or unexported fields
}

ColumnAccessExpr represents (E).x expressions. Specifically, it allows accessing the column(s) from a Set Returning Function.

func NewTypedColumnAccessExpr 

func NewTypedColumnAccessExpr(expr TypedExpr, colName string, colIdx int) *ColumnAccessExpr

NewTypedColumnAccessExpr creates a pre-typed ColumnAccessExpr. A by-index ColumnAccessExpr can be specified by passing an empty string as colName.

func (*ColumnAccessExpr) Eval 

func (expr *ColumnAccessExpr) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*ColumnAccessExpr) Format 

func (node *ColumnAccessExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (ColumnAccessExpr) ResolvedType 

func (ta ColumnAccessExpr) ResolvedType() *types.T

func (*ColumnAccessExpr) String 

func (node *ColumnAccessExpr) String() string

func (*ColumnAccessExpr) TypeCheck 

func (expr *ColumnAccessExpr) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*ColumnAccessExpr) Walk 

func (expr *ColumnAccessExpr) Walk(v Visitor) Expr

Walk implements the Expr interface.

type ColumnCheckConstraint 

type ColumnCheckConstraint struct {
	Expr Expr
}

ColumnCheckConstraint represents either a check on a column.

type ColumnCollation 

type ColumnCollation string

ColumnCollation represents a COLLATE clause for a column.

type ColumnComputedDef 

type ColumnComputedDef struct {
	Expr Expr
}

ColumnComputedDef represents the description of a computed column.

type ColumnDefault 

type ColumnDefault struct {
	Expr Expr
}

ColumnDefault represents a DEFAULT clause for a column.

type ColumnFKConstraint 

type ColumnFKConstraint struct {
	Table   TableName
	Col     Name // empty-string means use PK
	Actions ReferenceActions
	Match   CompositeKeyMatchMethod
}

ColumnFKConstraint represents a FK-constaint on a column.

type ColumnFamilyConstraint 

type ColumnFamilyConstraint struct {
	Family      Name
	Create      bool
	IfNotExists bool
}

ColumnFamilyConstraint represents FAMILY on a column.

type ColumnID 

type ColumnID uint32

ColumnID is a custom type for ColumnDescriptor IDs.

type ColumnItem 

type ColumnItem struct {
	// TableName holds the table prefix, if the name refers to a column. It is
	// optional.
	//
	// This uses UnresolvedObjectName because we need to preserve the
	// information about which parts were initially specified in the SQL
	// text. ColumnItems are intermediate data structures anyway, that
	// still need to undergo name resolution.
	TableName *UnresolvedObjectName
	// ColumnName names the designated column.
	ColumnName Name
}

ColumnItem corresponds to the name of a column in an expression.

func MakeColumnItem 

func MakeColumnItem(tn *TableName, colName Name) ColumnItem

MakeColumnItem constructs a column item from an already valid TableName. This can be used for e.g. pretty-printing.

func NewColumnItem 

func NewColumnItem(tn *TableName, colName Name) *ColumnItem

NewColumnItem constructs a column item from an already valid TableName. This can be used for e.g. pretty-printing.

func (*ColumnItem) Column 

func (c *ColumnItem) Column() string

Column retrieves the unqualified column name.

func (*ColumnItem) Eval 

func (expr *ColumnItem) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*ColumnItem) Format 

func (c *ColumnItem) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface. If this is updated, then dummyColumnItem.Format should be updated as well.

func (*ColumnItem) NormalizeVarName 

func (c *ColumnItem) NormalizeVarName() (VarName, error)

NormalizeVarName implements the VarName interface.

func (*ColumnItem) Resolve 

func (c *ColumnItem) Resolve(
	ctx context.Context, r ColumnItemResolver,
) (ColumnResolutionResult, error)

Resolve performs name resolution for a column item using a resolver.

func (*ColumnItem) ResolvedType 

func (c *ColumnItem) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*ColumnItem) String 

func (c *ColumnItem) String() string

func (*ColumnItem) TypeCheck 

func (expr *ColumnItem) TypeCheck(
	_ context.Context, _ *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface. This function has a valid implementation only for testing within this package. During query execution, ColumnItems are replaced to IndexedVars prior to type checking.

func (*ColumnItem) Variable 

func (c *ColumnItem) Variable()

Variable implements the VariableExpr interface.

Note that in common uses, ColumnItem ought to be replaced to an IndexedVar prior to evaluation.

func (*ColumnItem) Walk 

func (expr *ColumnItem) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type ColumnItemResolver 

type ColumnItemResolver interface {
	// FindSourceMatchingName searches for a data source with name tn.
	//
	// This must error out with "ambiguous table name" if there is more
	// than one data source matching tn. The srcMeta is subsequently
	// passed to Resolve() if resolution succeeds. The prefix will not be
	// modified.
	FindSourceMatchingName(ctx context.Context, tn TableName) (res NumResolutionResults, prefix *TableName, srcMeta ColumnSourceMeta, err error)

	// FindSourceProvidingColumn searches for a data source providing
	// a column with the name given.
	//
	// This must error out with "ambiguous column name" if there is more
	// than one data source matching tn, "column not found" if there is
	// none. The srcMeta and colHints are subsequently passed to
	// Resolve() if resolution succeeds. The prefix will not be
	// modified.
	FindSourceProvidingColumn(ctx context.Context, col Name) (prefix *TableName, srcMeta ColumnSourceMeta, colHint int, err error)

	// Resolve() is called if resolution succeeds.
	Resolve(ctx context.Context, prefix *TableName, srcMeta ColumnSourceMeta, colHint int, col Name) (ColumnResolutionResult, error)
}

ColumnItemResolver is the helper interface to resolve column items.

type ColumnMutationCmd 

type ColumnMutationCmd interface {
	AlterTableCmd
	GetColumn() Name
}

ColumnMutationCmd is the subset of AlterTableCmds that modify an existing column.

type ColumnQualification 

type ColumnQualification interface {
	// contains filtered or unexported methods
}

ColumnQualification represents a constraint on a column.

type ColumnResolutionResult 

type ColumnResolutionResult interface {
	// ColumnResolutionResult is the interface anchor.
	ColumnResolutionResult()
}

ColumnResolutionResult is an opaque reference returned by ColumnItemResolver.Resolve().

type ColumnSourceMeta 

type ColumnSourceMeta interface {
	// ColumnSourcMeta is the interface anchor.
	ColumnSourceMeta()
}

ColumnSourceMeta is an opaque reference passed through column item resolution.

type ColumnTableDef 

type ColumnTableDef struct {
	Name     Name
	Type     ResolvableTypeReference
	IsSerial bool
	Nullable struct {
		Nullability    Nullability
		ConstraintName Name
	}
	PrimaryKey struct {
		IsPrimaryKey bool
		Sharded      bool
		ShardBuckets Expr
	}
	Unique               bool
	UniqueConstraintName Name
	DefaultExpr          struct {
		Expr           Expr
		ConstraintName Name
	}
	CheckExprs []ColumnTableDefCheckExpr
	References struct {
		Table          *TableName
		Col            Name
		ConstraintName Name
		Actions        ReferenceActions
		Match          CompositeKeyMatchMethod
	}
	Computed struct {
		Computed bool
		Expr     Expr
	}
	Family struct {
		Name        Name
		Create      bool
		IfNotExists bool
	}
}

ColumnTableDef represents a column definition within a CREATE TABLE statement.

func NewColumnTableDef 

func NewColumnTableDef(
	name Name,
	typRef ResolvableTypeReference,
	isSerial bool,
	qualifications []NamedColumnQualification,
) (*ColumnTableDef, error)

NewColumnTableDef constructs a column definition for a CreateTable statement.

func (*ColumnTableDef) Format 

func (node *ColumnTableDef) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ColumnTableDef) HasColumnFamily 

func (node *ColumnTableDef) HasColumnFamily() bool

HasColumnFamily returns if the ColumnTableDef has a column family.

func (*ColumnTableDef) HasDefaultExpr 

func (node *ColumnTableDef) HasDefaultExpr() bool

HasDefaultExpr returns if the ColumnTableDef has a default expression.

func (*ColumnTableDef) HasFKConstraint 

func (node *ColumnTableDef) HasFKConstraint() bool

HasFKConstraint returns if the ColumnTableDef has a foreign key constraint.

func (*ColumnTableDef) IsComputed 

func (node *ColumnTableDef) IsComputed() bool

IsComputed returns if the ColumnTableDef is a computed column.

func (*ColumnTableDef) String 

func (node *ColumnTableDef) String() string

String implements the fmt.Stringer interface.

type ColumnTableDefCheckExpr 

type ColumnTableDefCheckExpr struct {
	Expr           Expr
	ConstraintName Name
}

ColumnTableDefCheckExpr represents a check constraint on a column definition within a CREATE TABLE statement.

type CommentOnColumn 

type CommentOnColumn struct {
	*ColumnItem
	Comment *string
}

CommentOnColumn represents an COMMENT ON COLUMN statement.

func (*CommentOnColumn) Format 

func (n *CommentOnColumn) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*CommentOnColumn) StatementTag 

func (*CommentOnColumn) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*CommentOnColumn) StatementType 

func (*CommentOnColumn) StatementType() StatementType

StatementType implements the Statement interface.

func (*CommentOnColumn) String 

func (n *CommentOnColumn) String() string

type CommentOnDatabase 

type CommentOnDatabase struct {
	Name    Name
	Comment *string
}

CommentOnDatabase represents an COMMENT ON DATABASE statement.

func (*CommentOnDatabase) Format 

func (n *CommentOnDatabase) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*CommentOnDatabase) StatementTag 

func (*CommentOnDatabase) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*CommentOnDatabase) StatementType 

func (*CommentOnDatabase) StatementType() StatementType

StatementType implements the Statement interface.

func (*CommentOnDatabase) String 

func (n *CommentOnDatabase) String() string

type CommentOnIndex 

type CommentOnIndex struct {
	Index   TableIndexName
	Comment *string
}

CommentOnIndex represents a COMMENT ON INDEX statement.

func (*CommentOnIndex) Format 

func (n *CommentOnIndex) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*CommentOnIndex) StatementTag 

func (*CommentOnIndex) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*CommentOnIndex) StatementType 

func (*CommentOnIndex) StatementType() StatementType

StatementType implements the Statement interface.

func (*CommentOnIndex) String 

func (n *CommentOnIndex) String() string

type CommentOnTable 

type CommentOnTable struct {
	Table   *UnresolvedObjectName
	Comment *string
}

CommentOnTable represents an COMMENT ON TABLE statement.

func (*CommentOnTable) Format 

func (n *CommentOnTable) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*CommentOnTable) StatementTag 

func (*CommentOnTable) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*CommentOnTable) StatementType 

func (*CommentOnTable) StatementType() StatementType

StatementType implements the Statement interface.

func (*CommentOnTable) String 

func (n *CommentOnTable) String() string

type CommitTransaction 

type CommitTransaction struct{}

CommitTransaction represents a COMMIT statement.

func (*CommitTransaction) Format 

func (node *CommitTransaction) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*CommitTransaction) StatementTag 

func (*CommitTransaction) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*CommitTransaction) StatementType 

func (*CommitTransaction) StatementType() StatementType

StatementType implements the Statement interface.

func (*CommitTransaction) String 

func (n *CommitTransaction) String() string

type CommonLookupFlags 

type CommonLookupFlags struct {
	// if required is set, lookup will return an error if the item is not found.
	Required bool
	// if AvoidCached is set, lookup will avoid the cache (if any).
	AvoidCached bool
}

CommonLookupFlags is the common set of flags for the various accessor interfaces.

type ComparisonExpr 

type ComparisonExpr struct {
	Operator    ComparisonOperator
	SubOperator ComparisonOperator // used for array operators (when Operator is Any, Some, or All)
	Left, Right Expr
	// contains filtered or unexported fields
}

ComparisonExpr represents a two-value comparison expression.

func NewTypedComparisonExpr 

func NewTypedComparisonExpr(op ComparisonOperator, left, right TypedExpr) *ComparisonExpr

NewTypedComparisonExpr returns a new ComparisonExpr that is verified to be well-typed.

func NewTypedComparisonExprWithSubOp 

func NewTypedComparisonExprWithSubOp(
	op, subOp ComparisonOperator, left, right TypedExpr,
) *ComparisonExpr

NewTypedComparisonExprWithSubOp returns a new ComparisonExpr that is verified to be well-typed.

func (*ComparisonExpr) Eval 

func (expr *ComparisonExpr) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*ComparisonExpr) Format 

func (node *ComparisonExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (ComparisonExpr) ResolvedType 

func (ta ComparisonExpr) ResolvedType() *types.T

func (*ComparisonExpr) String 

func (node *ComparisonExpr) String() string

func (*ComparisonExpr) TypeCheck 

func (expr *ComparisonExpr) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*ComparisonExpr) TypedLeft 

func (node *ComparisonExpr) TypedLeft() TypedExpr

TypedLeft returns the ComparisonExpr's left expression as a TypedExpr.

func (*ComparisonExpr) TypedRight 

func (node *ComparisonExpr) TypedRight() TypedExpr

TypedRight returns the ComparisonExpr's right expression as a TypedExpr.

func (*ComparisonExpr) Walk 

func (expr *ComparisonExpr) Walk(v Visitor) Expr

Walk implements the Expr interface.

type ComparisonOperator 

type ComparisonOperator int

ComparisonOperator represents a binary operator. 

const (
	EQ ComparisonOperator = iota
	LT
	GT
	LE
	GE
	NE
	In
	NotIn
	Like
	NotLike
	ILike
	NotILike
	SimilarTo
	NotSimilarTo
	RegMatch
	NotRegMatch
	RegIMatch
	NotRegIMatch
	IsDistinctFrom
	IsNotDistinctFrom
	Contains
	ContainedBy
	JSONExists
	JSONSomeExists
	JSONAllExists
	Overlaps

	// The following operators will always be used with an associated SubOperator.
	// If Go had algebraic data types they would be defined in a self-contained
	// manner like:
	//
	// Any(ComparisonOperator)
	// Some(ComparisonOperator)
	// ...
	//
	// where the internal ComparisonOperator qualifies the behavior of the primary
	// operator. Instead, a secondary ComparisonOperator is optionally included in
	// ComparisonExpr for the cases where these operators are the primary op.
	//
	// ComparisonOperator.hasSubOperator returns true for ops in this group.
	Any
	Some
	All

	NumComparisonOperators
)

ComparisonExpr.Operator

func (ComparisonOperator) Inverse 

func (i ComparisonOperator) Inverse() (ComparisonOperator, bool)

Inverse returns the inverse of this comparison operator if it exists. The second return value is true if it exists, and false otherwise.

func (ComparisonOperator) String 

func (i ComparisonOperator) String() string

type CompositeDatum 

type CompositeDatum interface {
	Datum
	// IsComposite returns true if this datum is not round-tripable in a key
	// encoding.
	IsComposite() bool
}

CompositeDatum is a Datum that may require composite encoding in indexes. Any Datum implementing this interface must also add itself to sqlbase/HasCompositeKeyEncoding.

type CompositeKeyMatchMethod 

type CompositeKeyMatchMethod int

CompositeKeyMatchMethod is the algorithm use when matching composite keys. See https://pgparser /issues/20305 or https://www.postgresql.org/docs/11/sql-createtable.html for details on the different composite foreign key matching methods. 

const (
	MatchSimple CompositeKeyMatchMethod = iota
	MatchFull
	MatchPartial // Note: PARTIAL not actually supported at this point.
)

The values for CompositeKeyMatchMethod.

func (CompositeKeyMatchMethod) String 

func (c CompositeKeyMatchMethod) String() string

type Constant 

type Constant interface {
	Expr
	// AvailableTypes returns the ordered set of types that the Constant is able to
	// be resolved into. The order of the type slice provides a notion of precedence,
	// with the first element in the ordering being the Constant's "natural type".
	AvailableTypes() []*types.T
	// DesirableTypes returns the ordered set of types that the constant would
	// prefer to be resolved into. As in AvailableTypes, the order of the returned
	// type slice provides a notion of precedence, with the first element in the
	// ordering being the Constant's "natural type." The function is meant to be
	// differentiated from AvailableTypes in that it will exclude certain types
	// that are possible, but not desirable.
	//
	// An example of this is a floating point numeric constant without a value
	// past the decimal point. It is possible to resolve this constant as a
	// decimal, but it is not desirable.
	DesirableTypes() []*types.T
	// ResolveAsType resolves the Constant as the specified type, or returns an
	// error if the Constant could not be resolved as that type. The method should
	// only be passed a type returned from AvailableTypes and should never be
	// called more than once for a given Constant.
	//
	// The returned expression is either a Datum or a CastExpr wrapping a Datum;
	// the latter is necessary for cases where the result would depend on the
	// context (like the timezone or the current time).
	ResolveAsType(context.Context, *SemaContext, *types.T) (TypedExpr, error)
}

Constant is an constant literal expression which may be resolved to more than one type.

type ConstantEvalVisitor 

type ConstantEvalVisitor struct {
	// contains filtered or unexported fields
}

ConstantEvalVisitor replaces constant TypedExprs with the result of Eval.

func MakeConstantEvalVisitor 

func MakeConstantEvalVisitor(ctx *EvalContext) ConstantEvalVisitor

MakeConstantEvalVisitor creates a ConstantEvalVisitor instance.

func (*ConstantEvalVisitor) Err 

func (v *ConstantEvalVisitor) Err() error

Err retrieves the error field in the ConstantEvalVisitor.

func (*ConstantEvalVisitor) VisitPost 

func (v *ConstantEvalVisitor) VisitPost(expr Expr) Expr

VisitPost implements the Visitor interface.

func (*ConstantEvalVisitor) VisitPre 

func (v *ConstantEvalVisitor) VisitPre(expr Expr) (recurse bool, newExpr Expr)

VisitPre implements the Visitor interface.

type ConstraintTableDef 

type ConstraintTableDef interface {
	TableDef

	// SetName replaces the name of the definition in-place. Used in the parser.
	SetName(name Name)
	// contains filtered or unexported methods
}

ConstraintTableDef represents a constraint definition within a CREATE TABLE statement.

type ControlJobs 

type ControlJobs struct {
	Jobs    *Select
	Command JobCommand
}

ControlJobs represents a PAUSE/RESUME/CANCEL JOBS statement.

func (*ControlJobs) Format 

func (n *ControlJobs) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ControlJobs) StatementTag 

func (n *ControlJobs) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ControlJobs) StatementType 

func (*ControlJobs) StatementType() StatementType

StatementType implements the Statement interface.

func (*ControlJobs) String 

func (n *ControlJobs) String() string

type CopyFrom 

type CopyFrom struct {
	Table   TableName
	Columns NameList
	Stdin   bool
	Options KVOptions
}

CopyFrom represents a COPY FROM statement.

func (*CopyFrom) Format 

func (node *CopyFrom) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*CopyFrom) StatementTag 

func (*CopyFrom) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*CopyFrom) StatementType 

func (*CopyFrom) StatementType() StatementType

StatementType implements the Statement interface.

func (*CopyFrom) String 

func (n *CopyFrom) String() string

type CreateChangefeed 

type CreateChangefeed struct {
	Targets TargetList
	SinkURI Expr
	Options KVOptions
}

CreateChangefeed represents a CREATE CHANGEFEED statement.

func (*CreateChangefeed) Format 

func (node *CreateChangefeed) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*CreateChangefeed) StatementTag 

func (n *CreateChangefeed) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*CreateChangefeed) StatementType 

func (*CreateChangefeed) StatementType() StatementType

StatementType implements the Statement interface.

func (*CreateChangefeed) String 

func (n *CreateChangefeed) String() string

type CreateDatabase 

type CreateDatabase struct {
	IfNotExists bool
	Name        Name
	Template    string
	Encoding    string
	Collate     string
	CType       string
}

CreateDatabase represents a CREATE DATABASE statement.

func (*CreateDatabase) Format 

func (node *CreateDatabase) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*CreateDatabase) StatementTag 

func (*CreateDatabase) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*CreateDatabase) StatementType 

func (*CreateDatabase) StatementType() StatementType

StatementType implements the Statement interface.

func (*CreateDatabase) String 

func (n *CreateDatabase) String() string

type CreateIndex 

type CreateIndex struct {
	Name        Name
	Table       TableName
	Unique      bool
	Inverted    bool
	IfNotExists bool
	Columns     IndexElemList
	Sharded     *ShardedIndexDef
	// Extra columns to be stored together with the indexed ones as an optimization
	// for improved reading performance.
	Storing      NameList
	Interleave   *InterleaveDef
	PartitionBy  *PartitionBy
	Predicate    Expr
	Concurrently bool
}

CreateIndex represents a CREATE INDEX statement.

func (*CreateIndex) Format 

func (node *CreateIndex) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*CreateIndex) StatementTag 

func (*CreateIndex) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*CreateIndex) StatementType 

func (*CreateIndex) StatementType() StatementType

StatementType implements the Statement interface.

func (*CreateIndex) String 

func (n *CreateIndex) String() string

type CreateRole 

type CreateRole struct {
	Name        Expr
	IfNotExists bool
	IsRole      bool
	KVOptions   KVOptions
}

CreateRole represents a CREATE ROLE statement.

func (*CreateRole) Format 

func (node *CreateRole) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*CreateRole) StatementTag 

func (*CreateRole) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*CreateRole) StatementType 

func (*CreateRole) StatementType() StatementType

StatementType implements the Statement interface.

func (*CreateRole) String 

func (n *CreateRole) String() string

type CreateSchema 

type CreateSchema struct {
	IfNotExists bool
	Schema      string
}

CreateSchema represents a CREATE SCHEMA statement.

func (*CreateSchema) Format 

func (node *CreateSchema) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*CreateSchema) StatementTag 

func (n *CreateSchema) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*CreateSchema) StatementType 

func (n *CreateSchema) StatementType() StatementType

StatementType implements the Statement interface.

func (*CreateSchema) String 

func (n *CreateSchema) String() string

type CreateSequence 

type CreateSequence struct {
	IfNotExists bool
	Name        TableName
	Temporary   bool
	Options     SequenceOptions
}

CreateSequence represents a CREATE SEQUENCE statement.

func (*CreateSequence) Format 

func (node *CreateSequence) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*CreateSequence) StatementTag 

func (*CreateSequence) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*CreateSequence) StatementType 

func (*CreateSequence) StatementType() StatementType

StatementType implements the Statement interface.

func (*CreateSequence) String 

func (n *CreateSequence) String() string

type CreateStats 

type CreateStats struct {
	Name        Name
	ColumnNames NameList
	Table       TableExpr
	Options     CreateStatsOptions
}

CreateStats represents a CREATE STATISTICS statement.

func (*CreateStats) Format 

func (node *CreateStats) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*CreateStats) StatementTag 

func (*CreateStats) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*CreateStats) StatementType 

func (*CreateStats) StatementType() StatementType

StatementType implements the Statement interface.

func (*CreateStats) String 

func (n *CreateStats) String() string

type CreateStatsOptions 

type CreateStatsOptions struct {
	// Throttling enables throttling and indicates the fraction of time we are
	// idling (between 0 and 1).
	Throttling float64

	// AsOf performs a historical read at the given timestamp.
	// Note that the timestamp will be moved up during the operation if it gets
	// too old (in order to avoid problems with TTL expiration).
	AsOf AsOfClause
}

CreateStatsOptions contains options for CREATE STATISTICS.

func (*CreateStatsOptions) CombineWith 

func (o *CreateStatsOptions) CombineWith(other *CreateStatsOptions) error

CombineWith combines two options, erroring out if the two options contain incompatible settings.

func (*CreateStatsOptions) Empty 

func (o *CreateStatsOptions) Empty() bool

Empty returns true if no options were provided.

func (*CreateStatsOptions) Format 

func (o *CreateStatsOptions) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type CreateTable 

type CreateTable struct {
	IfNotExists   bool
	Table         TableName
	Interleave    *InterleaveDef
	PartitionBy   *PartitionBy
	Temporary     bool
	StorageParams StorageParams
	OnCommit      CreateTableOnCommitSetting
	// In CREATE...AS queries, Defs represents a list of ColumnTableDefs, one for
	// each column, and a ConstraintTableDef for each constraint on a subset of
	// these columns.
	Defs     TableDefs
	AsSource *Select
}

CreateTable represents a CREATE TABLE statement.

func (*CreateTable) As 

func (node *CreateTable) As() bool

As returns true if this table represents a CREATE TABLE ... AS statement, false otherwise.

func (*CreateTable) AsHasUserSpecifiedPrimaryKey 

func (node *CreateTable) AsHasUserSpecifiedPrimaryKey() bool

AsHasUserSpecifiedPrimaryKey returns true if a CREATE TABLE ... AS statement has a PRIMARY KEY constraint specified.

func (*CreateTable) Format 

func (node *CreateTable) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*CreateTable) FormatBody 

func (node *CreateTable) FormatBody(ctx *FmtCtx)

FormatBody formats the "body" of the create table definition - everything but the CREATE TABLE tableName part.

func (*CreateTable) HoistConstraints 

func (node *CreateTable) HoistConstraints()

HoistConstraints finds column check and foreign key constraints defined inline with their columns and makes them table-level constraints, stored in n.Defs. For example, the foreign key constraint in 

CREATE TABLE foo (a INT REFERENCES bar(a))

gets pulled into a top-level constraint like: 

CREATE TABLE foo (a INT, FOREIGN KEY (a) REFERENCES bar(a))

Similarly, the CHECK constraint in 

CREATE TABLE foo (a INT CHECK (a < 1), b INT)

gets pulled into a top-level constraint like: 

CREATE TABLE foo (a INT, b INT, CHECK (a < 1))

Note that some SQL databases require that a constraint attached to a column to refer only to the column it is attached to. We follow Postgres' behavior, however, in omitting this restriction by blindly hoisting all column constraints. For example, the following table definition is accepted in CockroachDB and Postgres, but not necessarily other SQL databases: 

CREATE TABLE foo (a INT CHECK (a < b), b INT)

Unique constraints are not hoisted.

func (*CreateTable) StatementTag 

func (n *CreateTable) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*CreateTable) StatementType 

func (n *CreateTable) StatementType() StatementType

StatementType implements the Statement interface.

func (*CreateTable) String 

func (n *CreateTable) String() string

type CreateTableOnCommitSetting 

type CreateTableOnCommitSetting uint32

CreateTableOnCommitSetting represents the CREATE TABLE ... ON COMMIT <action> parameters. 

const (
	// CreateTableOnCommitUnset indicates that ON COMMIT was unset.
	CreateTableOnCommitUnset CreateTableOnCommitSetting = iota
	// CreateTableOnCommitPreserveRows indicates that ON COMMIT PRESERVE ROWS was set.
	CreateTableOnCommitPreserveRows
)

type CreateType 

type CreateType struct {
	TypeName *UnresolvedObjectName
	Variety  CreateTypeVariety
	// EnumLabels is set when this represents a CREATE TYPE ... AS ENUM statement.
	EnumLabels []string
}

CreateType represents a CREATE TYPE statement.

func (*CreateType) Format 

func (node *CreateType) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*CreateType) StatementTag 

func (*CreateType) StatementTag() string

StatementTag implements the Statement interface.

func (*CreateType) StatementType 

func (*CreateType) StatementType() StatementType

StatementType implements the Statement interface.

func (*CreateType) String 

func (node *CreateType) String() string

type CreateTypeVariety 

type CreateTypeVariety int

CreateTypeVariety represents a particular variety of user defined types. 

const (

	// Enum represents an ENUM user defined type.
	Enum CreateTypeVariety
	// Composite represents a composite user defined type.
	Composite
	// Range represents a RANGE user defined type.
	Range
	// Base represents a base user defined type.
	Base
	// Shell represents a shell user defined type.
	Shell
	// Domain represents a DOMAIN user defined type.
	Domain
)

func (CreateTypeVariety) String 

func (i CreateTypeVariety) String() string

type CreateView 

type CreateView struct {
	Name        TableName
	ColumnNames NameList
	AsSource    *Select
	IfNotExists bool
	Temporary   bool
	Replace     bool
}

CreateView represents a CREATE VIEW statement.

func (*CreateView) Format 

func (node *CreateView) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*CreateView) StatementTag 

func (*CreateView) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*CreateView) StatementType 

func (*CreateView) StatementType() StatementType

StatementType implements the Statement interface.

func (*CreateView) String 

func (n *CreateView) String() string

type DArray 

type DArray struct {
	ParamTyp *types.T
	Array    Datums
	// HasNulls is set to true if any of the datums within the array are null.
	// This is used in the binary array serialization format.
	HasNulls bool
	// HasNonNulls is set to true if any of the datums within the are non-null.
	// This is used in expression serialization (FmtParsable).
	HasNonNulls bool
	// contains filtered or unexported fields
}

DArray is the array Datum. Any Datum inserted into a DArray are treated as text during serialization.

func AsDArray 

func AsDArray(e Expr) (*DArray, bool)

AsDArray attempts to retrieve a *DArray from an Expr, returning a *DArray and a flag signifying whether the assertion was successful. The function should be used instead of direct type assertions wherever a *DArray wrapped by a *DOidWrapper is possible.

func MustBeDArray 

func MustBeDArray(e Expr) *DArray

MustBeDArray attempts to retrieve a *DArray from an Expr, panicking if the assertion fails.

func NewDArray 

func NewDArray(paramTyp *types.T) *DArray

NewDArray returns a DArray containing elements of the specified type.

func ParseDArrayFromString 

func ParseDArrayFromString(
	ctx ParseTimeContext, s string, t *types.T,
) (_ *DArray, dependsOnContext bool, _ error)

ParseDArrayFromString parses the string-form of constructing arrays, handling cases such as `'{1,2,3}'::INT[]`. The input type t is the type of the parameter of the array to parse.

The dependsOnContext return value indicates if we had to consult the ParseTimeContext (either for the time or the local timezone).

func (*DArray) AmbiguousFormat 

func (d *DArray) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DArray) Append 

func (d *DArray) Append(v Datum) error

Append appends a Datum to the array, whose parameterized type must be consistent with the type of the Datum.

func (*DArray) Compare 

func (d *DArray) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DArray) Eval 

func (t *DArray) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DArray) FirstIndex 

func (d *DArray) FirstIndex() int

FirstIndex returns the first index of the array. 1 for normal SQL arrays, which are 1-indexed, and 0 for the special Postgers vector types which are 0-indexed.

func (*DArray) Format 

func (d *DArray) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DArray) IsComposite 

func (d *DArray) IsComposite() bool

IsComposite implements the CompositeDatum interface.

func (*DArray) IsMax 

func (d *DArray) IsMax(_ *EvalContext) bool

IsMax implements the Datum interface.

func (*DArray) IsMin 

func (d *DArray) IsMin(_ *EvalContext) bool

IsMin implements the Datum interface.

func (*DArray) Len 

func (d *DArray) Len() int

Len returns the length of the Datum array.

func (*DArray) Max 

func (d *DArray) Max(_ *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DArray) Min 

func (d *DArray) Min(_ *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DArray) Next 

func (d *DArray) Next(_ *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DArray) Prev 

func (d *DArray) Prev(_ *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DArray) ResolvedType 

func (d *DArray) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*DArray) Size 

func (d *DArray) Size() uintptr

Size implements the Datum interface.

func (*DArray) String 

func (node *DArray) String() string

func (*DArray) TypeCheck 

func (d *DArray) TypeCheck(_ context.Context, _ *SemaContext, desired *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DArray) Validate 

func (d *DArray) Validate() error

Validate checks that the given array is valid, for example, that it's not too big.

func (*DArray) Walk 

func (expr *DArray) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DBitArray 

type DBitArray struct {
	bitarray.BitArray
}

DBitArray is the BIT/VARBIT Datum.

func AsDBitArray 

func AsDBitArray(e Expr) (*DBitArray, bool)

AsDBitArray attempts to retrieve a *DBitArray from an Expr, returning a *DBitArray and a flag signifying whether the assertion was successful. The function should be used instead of direct type assertions.

func MakeDBitArray 

func MakeDBitArray(bitLen uint) DBitArray

MakeDBitArray returns a DBitArray.

func MustBeDBitArray 

func MustBeDBitArray(e Expr) *DBitArray

MustBeDBitArray attempts to retrieve a DBitArray from an Expr, panicking if the assertion fails.

func NewDBitArray 

func NewDBitArray(bitLen uint) *DBitArray

NewDBitArray returns a DBitArray.

func NewDBitArrayFromInt 

func NewDBitArrayFromInt(i int64, width uint) (*DBitArray, error)

NewDBitArrayFromInt creates a bit array from the specified integer at the specified width. If the width is zero, only positive integers can be converted. If the width is nonzero, the value is truncated to that width. Negative values are encoded using two's complement.

func ParseDBitArray 

func ParseDBitArray(s string) (*DBitArray, error)

ParseDBitArray parses a string representation of binary digits.

func (*DBitArray) AmbiguousFormat 

func (*DBitArray) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DBitArray) AsDInt 

func (d *DBitArray) AsDInt(n uint) *DInt

AsDInt computes the integer value of the given bit array. The value is assumed to be encoded using two's complement. The result is truncated to the given integer number of bits, if specified. The given width must be 64 or smaller. The results are undefined if n is greater than 64.

func (*DBitArray) Compare 

func (d *DBitArray) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DBitArray) Eval 

func (t *DBitArray) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DBitArray) Format 

func (d *DBitArray) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DBitArray) IsMax 

func (d *DBitArray) IsMax(_ *EvalContext) bool

IsMax implements the Datum interface.

func (*DBitArray) IsMin 

func (d *DBitArray) IsMin(_ *EvalContext) bool

IsMin implements the Datum interface.

func (*DBitArray) Max 

func (d *DBitArray) Max(_ *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DBitArray) Min 

func (d *DBitArray) Min(_ *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DBitArray) Next 

func (d *DBitArray) Next(_ *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DBitArray) Prev 

func (d *DBitArray) Prev(_ *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DBitArray) ResolvedType 

func (*DBitArray) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*DBitArray) Size 

func (d *DBitArray) Size() uintptr

Size implements the Datum interface.

func (*DBitArray) String 

func (node *DBitArray) String() string

func (*DBitArray) TypeCheck 

func (d *DBitArray) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DBitArray) Walk 

func (expr *DBitArray) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DBool 

type DBool bool

DBool is the boolean Datum.

func ArrayContains 

func ArrayContains(ctx *EvalContext, haystack *DArray, needles *DArray) (*DBool, error)

ArrayContains return true if the haystack contains all needles.

func AsDBool 

func AsDBool(e Expr) (DBool, bool)

AsDBool attempts to retrieve a *DBool from an Expr, returning a *DBool and a flag signifying whether the assertion was successful. The function should be used instead of direct type assertions.

func GetBool 

func GetBool(d Datum) (DBool, error)

GetBool gets DBool or an error (also treats NULL as false, not an error).

func MakeDBool 

func MakeDBool(d DBool) *DBool

MakeDBool converts its argument to a *DBool, returning either DBoolTrue or DBoolFalse.

func MustBeDBool 

func MustBeDBool(e Expr) DBool

MustBeDBool attempts to retrieve a DBool from an Expr, panicking if the assertion fails.

func ParseDBool 

func ParseDBool(s string) (*DBool, error)

ParseDBool parses and returns the *DBool Datum value represented by the provided string, or an error if parsing is unsuccessful. See https://github.com/postgres/postgres/blob/90627cf98a8e7d0531789391fd798c9bfcc3bc1a/src/backend/utils/adt/bool.c#L36

func (*DBool) AmbiguousFormat 

func (*DBool) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DBool) Compare 

func (d *DBool) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DBool) Eval 

func (t *DBool) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DBool) Format 

func (d *DBool) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DBool) IsMax 

func (d *DBool) IsMax(_ *EvalContext) bool

IsMax implements the Datum interface.

func (*DBool) IsMin 

func (d *DBool) IsMin(_ *EvalContext) bool

IsMin implements the Datum interface.

func (*DBool) Max 

func (d *DBool) Max(_ *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DBool) Min 

func (d *DBool) Min(_ *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DBool) Next 

func (*DBool) Next(_ *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DBool) Prev 

func (*DBool) Prev(_ *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DBool) ResolvedType 

func (*DBool) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*DBool) Size 

func (d *DBool) Size() uintptr

Size implements the Datum interface.

func (*DBool) String 

func (node *DBool) String() string

func (*DBool) TypeCheck 

func (d *DBool) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DBool) Walk 

func (expr *DBool) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DBytes 

type DBytes string

DBytes is the bytes Datum. The underlying type is a string because we want the immutability, but this may contain arbitrary bytes.

func AsDBytes 

func AsDBytes(e Expr) (DBytes, bool)

AsDBytes attempts to convert an Expr into a DBytes, returning a flag indicating whether it was successful.

func MustBeDBytes 

func MustBeDBytes(e Expr) DBytes

MustBeDBytes attempts to convert an Expr into a DBytes, panicking if unsuccessful.

func NewDBytes 

func NewDBytes(d DBytes) *DBytes

NewDBytes is a helper routine to create a *DBytes initialized from its argument.

func ParseDByte 

func ParseDByte(s string) (*DBytes, error)

ParseDByte parses a string representation of hex encoded binary data. It supports both the hex format, with "\x" followed by a string of hexadecimal digits (the "\x" prefix occurs just once at the beginning), and the escaped format, which supports "\\" and octal escapes.

func (*DBytes) AmbiguousFormat 

func (*DBytes) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DBytes) Compare 

func (d *DBytes) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DBytes) Eval 

func (t *DBytes) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DBytes) Format 

func (d *DBytes) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DBytes) IsMax 

func (*DBytes) IsMax(_ *EvalContext) bool

IsMax implements the Datum interface.

func (*DBytes) IsMin 

func (d *DBytes) IsMin(_ *EvalContext) bool

IsMin implements the Datum interface.

func (*DBytes) Max 

func (d *DBytes) Max(_ *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DBytes) Min 

func (d *DBytes) Min(_ *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DBytes) Next 

func (d *DBytes) Next(_ *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DBytes) Prev 

func (d *DBytes) Prev(_ *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DBytes) ResolvedType 

func (*DBytes) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*DBytes) Size 

func (d *DBytes) Size() uintptr

Size implements the Datum interface.

func (*DBytes) String 

func (node *DBytes) String() string

func (*DBytes) TypeCheck 

func (d *DBytes) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DBytes) Walk 

func (expr *DBytes) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DCollatedString 

type DCollatedString struct {
	Contents string
	Locale   string
	// Key is the collation key.
	Key []byte
}

DCollatedString is the Datum for strings with a locale. The struct members are intended to be immutable.

func NewDCollatedString 

func NewDCollatedString(
	contents string, locale string, env *CollationEnvironment,
) (*DCollatedString, error)

NewDCollatedString is a helper routine to create a *DCollatedString. Panics if locale is invalid. Not safe for concurrent use.

func (*DCollatedString) AmbiguousFormat 

func (*DCollatedString) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DCollatedString) Compare 

func (d *DCollatedString) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DCollatedString) Eval 

func (t *DCollatedString) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DCollatedString) Format 

func (d *DCollatedString) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DCollatedString) IsComposite 

func (d *DCollatedString) IsComposite() bool

IsComposite implements the CompositeDatum interface.

func (*DCollatedString) IsMax 

func (*DCollatedString) IsMax(_ *EvalContext) bool

IsMax implements the Datum interface.

func (*DCollatedString) IsMin 

func (d *DCollatedString) IsMin(_ *EvalContext) bool

IsMin implements the Datum interface.

func (*DCollatedString) Max 

func (d *DCollatedString) Max(_ *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DCollatedString) Min 

func (d *DCollatedString) Min(_ *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DCollatedString) Next 

func (d *DCollatedString) Next(_ *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DCollatedString) Prev 

func (d *DCollatedString) Prev(_ *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DCollatedString) ResolvedType 

func (d *DCollatedString) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*DCollatedString) Size 

func (d *DCollatedString) Size() uintptr

Size implements the Datum interface.

func (*DCollatedString) String 

func (node *DCollatedString) String() string

func (*DCollatedString) TypeCheck 

func (d *DCollatedString) TypeCheck(
	_ context.Context, _ *SemaContext, _ *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DCollatedString) Walk 

func (expr *DCollatedString) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DDate 

type DDate struct {
	pgdate.Date
}

DDate is the date Datum represented as the number of days after the Unix epoch.

func MakeDDate 

func MakeDDate(d pgdate.Date) DDate

MakeDDate makes a DDate from a pgdate.Date.

func NewDDate 

func NewDDate(d pgdate.Date) *DDate

NewDDate is a helper routine to create a *DDate initialized from its argument.

func NewDDateFromTime 

func NewDDateFromTime(t time.Time) (*DDate, error)

NewDDateFromTime constructs a *DDate from a time.Time.

func ParseDDate 

func ParseDDate(ctx ParseTimeContext, s string) (_ *DDate, dependsOnContext bool, _ error)

ParseDDate parses and returns the *DDate Datum value represented by the provided string in the provided location, or an error if parsing is unsuccessful.

The dependsOnContext return value indicates if we had to consult the ParseTimeContext (either for the time or the local timezone).

func (*DDate) AmbiguousFormat 

func (*DDate) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DDate) Compare 

func (d *DDate) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DDate) Eval 

func (t *DDate) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DDate) Format 

func (d *DDate) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DDate) IsMax 

func (d *DDate) IsMax(_ *EvalContext) bool

IsMax implements the Datum interface.

func (*DDate) IsMin 

func (d *DDate) IsMin(_ *EvalContext) bool

IsMin implements the Datum interface.

func (*DDate) Max 

func (d *DDate) Max(_ *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DDate) Min 

func (d *DDate) Min(_ *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DDate) Next 

func (d *DDate) Next(_ *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DDate) Prev 

func (d *DDate) Prev(_ *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DDate) ResolvedType 

func (*DDate) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*DDate) Size 

func (d *DDate) Size() uintptr

Size implements the Datum interface.

func (*DDate) String 

func (node *DDate) String() string

func (*DDate) TypeCheck 

func (d *DDate) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DDate) Walk 

func (expr *DDate) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DDecimal 

type DDecimal struct {
	apd.Decimal
}

DDecimal is the decimal Datum. 

var DecimalOne DDecimal

DecimalOne represents the constant 1 as DECIMAL.

func DecimalCbrt 

func DecimalCbrt(x *apd.Decimal) (*DDecimal, error)

DecimalCbrt returns the cube root of x.

func DecimalSqrt 

func DecimalSqrt(x *apd.Decimal) (*DDecimal, error)

DecimalSqrt returns the square root of x.

func MustBeDDecimal 

func MustBeDDecimal(e Expr) DDecimal

MustBeDDecimal attempts to retrieve a DDecimal from an Expr, panicking if the assertion fails.

func ParseDDecimal 

func ParseDDecimal(s string) (*DDecimal, error)

ParseDDecimal parses and returns the *DDecimal Datum value represented by the provided string, or an error if parsing is unsuccessful.

func TimestampToDecimal 

func TimestampToDecimal(ts hlc.Timestamp) *DDecimal

TimestampToDecimal converts the logical timestamp into a decimal value with the number of nanoseconds in the integer part and the logical counter in the decimal part.

func (*DDecimal) AmbiguousFormat 

func (*DDecimal) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DDecimal) Compare 

func (d *DDecimal) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DDecimal) Eval 

func (t *DDecimal) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DDecimal) Format 

func (d *DDecimal) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DDecimal) IsComposite 

func (d *DDecimal) IsComposite() bool

IsComposite implements the CompositeDatum interface.

func (*DDecimal) IsMax 

func (d *DDecimal) IsMax(_ *EvalContext) bool

IsMax implements the Datum interface.

func (*DDecimal) IsMin 

func (d *DDecimal) IsMin(_ *EvalContext) bool

IsMin implements the Datum interface.

func (*DDecimal) Max 

func (d *DDecimal) Max(_ *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DDecimal) Min 

func (d *DDecimal) Min(_ *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DDecimal) Next 

func (d *DDecimal) Next(_ *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DDecimal) Prev 

func (d *DDecimal) Prev(_ *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DDecimal) ResolvedType 

func (*DDecimal) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*DDecimal) SetString 

func (d *DDecimal) SetString(s string) error

SetString sets d to s. Any non-standard NaN values are converted to a normal NaN. Any negative zero is converted to positive.

func (*DDecimal) Size 

func (d *DDecimal) Size() uintptr

Size implements the Datum interface.

func (*DDecimal) String 

func (node *DDecimal) String() string

func (*DDecimal) TypeCheck 

func (d *DDecimal) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DDecimal) Walk 

func (expr *DDecimal) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DEnum 

type DEnum struct {
	// EnumType is the hydrated type of this enum.
	EnumTyp *types.T
	// PhysicalRep is a slice containing the encodable and ordered physical
	// representation of this datum. It is used for comparisons and encoding.
	PhysicalRep []byte
	// LogicalRep is a string containing the user visible value of the enum.
	LogicalRep string
}

DEnum represents an ENUM value.

func MakeDEnumFromLogicalRepresentation 

func MakeDEnumFromLogicalRepresentation(typ *types.T, rep string) (*DEnum, error)

MakeDEnumFromLogicalRepresentation creates a DEnum of the input type and input logical representation. It returns an error if the input logical representation is invalid.

func MakeDEnumFromPhysicalRepresentation 

func MakeDEnumFromPhysicalRepresentation(typ *types.T, rep []byte) (*DEnum, error)

MakeDEnumFromPhysicalRepresentation creates a DEnum of the input type and the input physical representation.

func (*DEnum) AmbiguousFormat 

func (d *DEnum) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DEnum) Compare 

func (d *DEnum) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DEnum) Eval 

func (t *DEnum) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DEnum) Format 

func (d *DEnum) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DEnum) IsMax 

func (d *DEnum) IsMax(_ *EvalContext) bool

IsMax implements the Datum interface.

func (*DEnum) IsMin 

func (d *DEnum) IsMin(_ *EvalContext) bool

IsMin implements the Datum interface.

func (*DEnum) Max 

func (d *DEnum) Max(ctx *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DEnum) Min 

func (d *DEnum) Min(ctx *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DEnum) Next 

func (d *DEnum) Next(ctx *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DEnum) Prev 

func (d *DEnum) Prev(ctx *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DEnum) ResolvedType 

func (d *DEnum) ResolvedType() *types.T

ResolvedType implements the Datum interface.

func (*DEnum) Size 

func (d *DEnum) Size() uintptr

Size implements the Datum interface.

func (*DEnum) String 

func (d *DEnum) String() string

func (*DEnum) TypeCheck 

func (d *DEnum) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DEnum) Walk 

func (expr *DEnum) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DFloat 

type DFloat float64

DFloat is the float Datum.

func Cbrt 

func Cbrt(x float64) (*DFloat, error)

Cbrt returns the cube root of x.

func MustBeDFloat 

func MustBeDFloat(e Expr) DFloat

MustBeDFloat attempts to retrieve a DFloat from an Expr, panicking if the assertion fails.

func NewDFloat 

func NewDFloat(d DFloat) *DFloat

NewDFloat is a helper routine to create a *DFloat initialized from its argument.

func ParseDFloat 

func ParseDFloat(s string) (*DFloat, error)

ParseDFloat parses and returns the *DFloat Datum value represented by the provided string, or an error if parsing is unsuccessful.

func Sqrt 

func Sqrt(x float64) (*DFloat, error)

Sqrt returns the square root of x.

func (*DFloat) AmbiguousFormat 

func (*DFloat) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DFloat) Compare 

func (d *DFloat) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DFloat) Eval 

func (t *DFloat) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DFloat) Format 

func (d *DFloat) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DFloat) IsComposite 

func (d *DFloat) IsComposite() bool

IsComposite implements the CompositeDatum interface.

func (*DFloat) IsMax 

func (d *DFloat) IsMax(_ *EvalContext) bool

IsMax implements the Datum interface.

func (*DFloat) IsMin 

func (d *DFloat) IsMin(_ *EvalContext) bool

IsMin implements the Datum interface.

func (*DFloat) Max 

func (d *DFloat) Max(_ *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DFloat) Min 

func (d *DFloat) Min(_ *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DFloat) Next 

func (d *DFloat) Next(_ *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DFloat) Prev 

func (d *DFloat) Prev(_ *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DFloat) ResolvedType 

func (*DFloat) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*DFloat) Size 

func (d *DFloat) Size() uintptr

Size implements the Datum interface.

func (*DFloat) String 

func (node *DFloat) String() string

func (*DFloat) TypeCheck 

func (d *DFloat) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DFloat) Walk 

func (expr *DFloat) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DGeography 

type DGeography struct {
	*geo.Geography
}

DGeography is the Geometry Datum.

func AsDGeography 

func AsDGeography(e Expr) (*DGeography, bool)

AsDGeography attempts to retrieve a *DGeography from an Expr, returning a *DGeography and a flag signifying whether the assertion was successful. The function should be used instead of direct type assertions wherever a *DGeography wrapped by a *DOidWrapper is possible.

func MustBeDGeography 

func MustBeDGeography(e Expr) *DGeography

MustBeDGeography attempts to retrieve a *DGeography from an Expr, panicking if the assertion fails.

func NewDGeography 

func NewDGeography(g *geo.Geography) *DGeography

NewDGeography returns a new Geography Datum.

func ParseDGeography 

func ParseDGeography(str string) (*DGeography, error)

ParseDGeography attempts to pass `str` as a Geography type.

func (*DGeography) AmbiguousFormat 

func (*DGeography) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DGeography) Compare 

func (d *DGeography) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DGeography) Eval 

func (t *DGeography) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DGeography) Format 

func (d *DGeography) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DGeography) IsMax 

func (d *DGeography) IsMax(_ *EvalContext) bool

IsMax implements the Datum interface.

func (*DGeography) IsMin 

func (d *DGeography) IsMin(_ *EvalContext) bool

IsMin implements the Datum interface.

func (*DGeography) Max 

func (d *DGeography) Max(_ *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DGeography) Min 

func (d *DGeography) Min(_ *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DGeography) Next 

func (d *DGeography) Next(ctx *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DGeography) Prev 

func (d *DGeography) Prev(ctx *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DGeography) ResolvedType 

func (*DGeography) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*DGeography) Size 

func (d *DGeography) Size() uintptr

Size implements the Datum interface.

func (*DGeography) String 

func (node *DGeography) String() string

func (*DGeography) TypeCheck 

func (d *DGeography) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DGeography) Walk 

func (expr *DGeography) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DGeometry 

type DGeometry struct {
	*geo.Geometry
}

DGeometry is the Geometry Datum.

func AsDGeometry 

func AsDGeometry(e Expr) (*DGeometry, bool)

AsDGeometry attempts to retrieve a *DGeometry from an Expr, returning a *DGeometry and a flag signifying whether the assertion was successful. The function should be used instead of direct type assertions wherever a *DGeometry wrapped by a *DOidWrapper is possible.

func MustBeDGeometry 

func MustBeDGeometry(e Expr) *DGeometry

MustBeDGeometry attempts to retrieve a *DGeometry from an Expr, panicking if the assertion fails.

func NewDGeometry 

func NewDGeometry(g *geo.Geometry) *DGeometry

NewDGeometry returns a new Geometry Datum.

func ParseDGeometry 

func ParseDGeometry(str string) (*DGeometry, error)

ParseDGeometry attempts to pass `str` as a Geometry type.

func (*DGeometry) AmbiguousFormat 

func (*DGeometry) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DGeometry) Compare 

func (d *DGeometry) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DGeometry) Eval 

func (t *DGeometry) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DGeometry) Format 

func (d *DGeometry) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DGeometry) IsMax 

func (d *DGeometry) IsMax(_ *EvalContext) bool

IsMax implements the Datum interface.

func (*DGeometry) IsMin 

func (d *DGeometry) IsMin(_ *EvalContext) bool

IsMin implements the Datum interface.

func (*DGeometry) Max 

func (d *DGeometry) Max(_ *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DGeometry) Min 

func (d *DGeometry) Min(_ *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DGeometry) Next 

func (d *DGeometry) Next(ctx *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DGeometry) Prev 

func (d *DGeometry) Prev(ctx *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DGeometry) ResolvedType 

func (*DGeometry) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*DGeometry) Size 

func (d *DGeometry) Size() uintptr

Size implements the Datum interface.

func (*DGeometry) String 

func (node *DGeometry) String() string

func (*DGeometry) TypeCheck 

func (d *DGeometry) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DGeometry) Walk 

func (expr *DGeometry) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DIPAddr 

type DIPAddr struct {
	ipaddr.IPAddr
}

DIPAddr is the IPAddr Datum.

func AsDIPAddr 

func AsDIPAddr(e Expr) (DIPAddr, bool)

AsDIPAddr attempts to retrieve a *DIPAddr from an Expr, returning a *DIPAddr and a flag signifying whether the assertion was successful. The function should be used instead of direct type assertions wherever a *DIPAddr wrapped by a *DOidWrapper is possible.

func MustBeDIPAddr 

func MustBeDIPAddr(e Expr) DIPAddr

MustBeDIPAddr attempts to retrieve a DIPAddr from an Expr, panicking if the assertion fails.

func NewDIPAddr 

func NewDIPAddr(d DIPAddr) *DIPAddr

NewDIPAddr is a helper routine to create a *DIPAddr initialized from its argument.

func ParseDIPAddrFromINetString 

func ParseDIPAddrFromINetString(s string) (*DIPAddr, error)

ParseDIPAddrFromINetString parses and returns the *DIPAddr Datum value represented by the provided input INet string, or an error.

func (*DIPAddr) AmbiguousFormat 

func (*DIPAddr) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DIPAddr) Compare 

func (d *DIPAddr) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DIPAddr) Eval 

func (t *DIPAddr) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DIPAddr) Format 

func (d *DIPAddr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DIPAddr) IsMax 

func (d *DIPAddr) IsMax(_ *EvalContext) bool

IsMax implements the Datum interface.

func (*DIPAddr) IsMin 

func (d *DIPAddr) IsMin(_ *EvalContext) bool

IsMin implements the Datum interface.

func (*DIPAddr) Max 

func (*DIPAddr) Max(_ *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DIPAddr) Min 

func (*DIPAddr) Min(_ *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DIPAddr) Next 

func (d *DIPAddr) Next(_ *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DIPAddr) Prev 

func (d *DIPAddr) Prev(_ *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DIPAddr) ResolvedType 

func (*DIPAddr) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*DIPAddr) Size 

func (d *DIPAddr) Size() uintptr

Size implements the Datum interface.

func (*DIPAddr) String 

func (node *DIPAddr) String() string

func (*DIPAddr) TypeCheck 

func (d *DIPAddr) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DIPAddr) Walk 

func (expr *DIPAddr) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DInt 

type DInt int64

DInt is the int Datum.

func AsDInt 

func AsDInt(e Expr) (DInt, bool)

AsDInt attempts to retrieve a DInt from an Expr, returning a DInt and a flag signifying whether the assertion was successful. The function should be used instead of direct type assertions wherever a *DInt wrapped by a *DOidWrapper is possible.

func IntPow 

func IntPow(x, y DInt) (*DInt, error)

IntPow computes the value of x^y.

func MustBeDInt 

func MustBeDInt(e Expr) DInt

MustBeDInt attempts to retrieve a DInt from an Expr, panicking if the assertion fails.

func NewDInt 

func NewDInt(d DInt) *DInt

NewDInt is a helper routine to create a *DInt initialized from its argument.

func ParseDInt 

func ParseDInt(s string) (*DInt, error)

ParseDInt parses and returns the *DInt Datum value represented by the provided string, or an error if parsing is unsuccessful.

func (*DInt) AmbiguousFormat 

func (*DInt) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DInt) Compare 

func (d *DInt) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DInt) Eval 

func (t *DInt) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DInt) Format 

func (d *DInt) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DInt) IsMax 

func (d *DInt) IsMax(_ *EvalContext) bool

IsMax implements the Datum interface.

func (*DInt) IsMin 

func (d *DInt) IsMin(_ *EvalContext) bool

IsMin implements the Datum interface.

func (*DInt) Max 

func (d *DInt) Max(_ *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DInt) Min 

func (d *DInt) Min(_ *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DInt) Next 

func (d *DInt) Next(_ *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DInt) Prev 

func (d *DInt) Prev(_ *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DInt) ResolvedType 

func (*DInt) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*DInt) Size 

func (d *DInt) Size() uintptr

Size implements the Datum interface.

func (*DInt) String 

func (node *DInt) String() string

func (*DInt) TypeCheck 

func (d *DInt) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DInt) Walk 

func (expr *DInt) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DInterval 

type DInterval struct {
	duration.Duration
}

DInterval is the interval Datum.

func MustBeDInterval 

func MustBeDInterval(e Expr) *DInterval

MustBeDInterval attempts to retrieve a DInterval from an Expr, panicking if the assertion fails.

func NewDInterval 

func NewDInterval(d duration.Duration, itm types.IntervalTypeMetadata) *DInterval

NewDInterval creates a new DInterval.

func ParseDInterval 

func ParseDInterval(s string) (*DInterval, error)

ParseDInterval parses and returns the *DInterval Datum value represented by the provided string, or an error if parsing is unsuccessful.

func ParseDIntervalWithTypeMetadata 

func ParseDIntervalWithTypeMetadata(s string, itm types.IntervalTypeMetadata) (*DInterval, error)

ParseDIntervalWithTypeMetadata is like ParseDInterval, but it also takes a types.IntervalTypeMetadata that both specifies the units for unitless, numeric intervals and also specifies the precision of the interval.

func (*DInterval) AmbiguousFormat 

func (*DInterval) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DInterval) Compare 

func (d *DInterval) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DInterval) Eval 

func (t *DInterval) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DInterval) Format 

func (d *DInterval) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DInterval) IsMax 

func (d *DInterval) IsMax(_ *EvalContext) bool

IsMax implements the Datum interface.

func (*DInterval) IsMin 

func (d *DInterval) IsMin(_ *EvalContext) bool

IsMin implements the Datum interface.

func (*DInterval) Max 

func (d *DInterval) Max(_ *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DInterval) Min 

func (d *DInterval) Min(_ *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DInterval) Next 

func (d *DInterval) Next(_ *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DInterval) Prev 

func (d *DInterval) Prev(_ *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DInterval) ResolvedType 

func (*DInterval) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*DInterval) Size 

func (d *DInterval) Size() uintptr

Size implements the Datum interface.

func (*DInterval) String 

func (node *DInterval) String() string

func (*DInterval) TypeCheck 

func (d *DInterval) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DInterval) ValueAsString 

func (d *DInterval) ValueAsString() string

ValueAsString returns the interval as a string (e.g. "1h2m").

func (*DInterval) Walk 

func (expr *DInterval) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DJSON 

type DJSON struct{ json.JSON }

DJSON is the JSON Datum.

func AsDJSON 

func AsDJSON(e Expr) (*DJSON, bool)

AsDJSON attempts to retrieve a *DJSON from an Expr, returning a *DJSON and a flag signifying whether the assertion was successful. The function should be used instead of direct type assertions wherever a *DJSON wrapped by a *DOidWrapper is possible.

func MustBeDJSON 

func MustBeDJSON(e Expr) DJSON

MustBeDJSON attempts to retrieve a DJSON from an Expr, panicking if the assertion fails.

func NewDJSON 

func NewDJSON(j json.JSON) *DJSON

NewDJSON is a helper routine to create a DJSON initialized from its argument.

func (*DJSON) AmbiguousFormat 

func (*DJSON) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DJSON) Compare 

func (d *DJSON) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DJSON) Eval 

func (t *DJSON) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DJSON) Format 

func (d *DJSON) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DJSON) IsMax 

func (d *DJSON) IsMax(_ *EvalContext) bool

IsMax implements the Datum interface.

func (*DJSON) IsMin 

func (d *DJSON) IsMin(_ *EvalContext) bool

IsMin implements the Datum interface.

func (*DJSON) Max 

func (d *DJSON) Max(_ *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DJSON) Min 

func (d *DJSON) Min(_ *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DJSON) Next 

func (d *DJSON) Next(_ *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DJSON) Prev 

func (d *DJSON) Prev(_ *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DJSON) ResolvedType 

func (*DJSON) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*DJSON) Size 

func (d *DJSON) Size() uintptr

Size implements the Datum interface. TODO(justin): is this a frequently-called method? Should we be caching the computed size?

func (*DJSON) String 

func (node *DJSON) String() string

func (*DJSON) TypeCheck 

func (d *DJSON) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DJSON) Walk 

func (expr *DJSON) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DOid 

type DOid struct {
	// A DOid embeds a DInt, the underlying integer OID for this OID datum.
	DInt
	// contains filtered or unexported fields
}

DOid is the Postgres OID datum. It can represent either an OID type or any of the reg* types, such as regproc or regclass.

func AsDOid 

func AsDOid(e Expr) (*DOid, bool)

AsDOid attempts to retrieve a DOid from an Expr, returning a DOid and a flag signifying whether the assertion was successful. The function should be used instead of direct type assertions wherever a *DOid wrapped by a *DOidWrapper is possible.

func MakeDOid 

func MakeDOid(d DInt) DOid

MakeDOid is a helper routine to create a DOid initialized from a DInt.

func MustBeDOid 

func MustBeDOid(e Expr) *DOid

MustBeDOid attempts to retrieve a DOid from an Expr, panicking if the assertion fails.

func NewDOid 

func NewDOid(d DInt) *DOid

NewDOid is a helper routine to create a *DOid initialized from a DInt.

func NewDOidWithName 

func NewDOidWithName(d DInt, typ *types.T, name string) *DOid

NewDOidWithName is a helper routine to create a *DOid initialized from a DInt and a string.

func (*DOid) AmbiguousFormat 

func (*DOid) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DOid) AsRegProc 

func (d *DOid) AsRegProc(name string) *DOid

AsRegProc changes the input DOid into a regproc with the given name and returns it.

func (*DOid) Compare 

func (d *DOid) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DOid) Eval 

func (t *DOid) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DOid) Format 

func (d *DOid) Format(ctx *FmtCtx)

Format implements the Datum interface.

func (*DOid) IsMax 

func (d *DOid) IsMax(ctx *EvalContext) bool

IsMax implements the Datum interface.

func (*DOid) IsMin 

func (d *DOid) IsMin(ctx *EvalContext) bool

IsMin implements the Datum interface.

func (*DOid) Max 

func (d *DOid) Max(ctx *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DOid) Min 

func (d *DOid) Min(ctx *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DOid) Next 

func (d *DOid) Next(ctx *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DOid) Prev 

func (d *DOid) Prev(ctx *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DOid) ResolvedType 

func (d *DOid) ResolvedType() *types.T

ResolvedType implements the Datum interface.

func (*DOid) Size 

func (d *DOid) Size() uintptr

Size implements the Datum interface.

func (*DOid) String 

func (node *DOid) String() string

func (*DOid) TypeCheck 

func (d *DOid) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DOid) Walk 

func (expr *DOid) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DOidWrapper 

type DOidWrapper struct {
	Wrapped Datum
	Oid     oid.Oid
}

DOidWrapper is a Datum implementation which is a wrapper around a Datum, allowing custom Oid values to be attached to the Datum and its types.T. The reason the Datum type was introduced was to permit the introduction of Datum types with new Object IDs while maintaining identical behavior to current Datum types. Specifically, it obviates the need to define a new ast.Datum type for each possible Oid value.

Instead, DOidWrapper allows a standard Datum to be wrapped with a new Oid. This approach provides two major advantages:

  • performance of the existing Datum types are not affected because they do not need to have custom oid.Oids added to their structure.
  • the introduction of new Datum aliases is straightforward and does not require additions to typing rules or type-dependent evaluation behavior.

Types that currently benefit from DOidWrapper are: - DName => DOidWrapper(*DString, oid.T_name)

func (*DOidWrapper) AmbiguousFormat 

func (d *DOidWrapper) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DOidWrapper) Compare 

func (d *DOidWrapper) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DOidWrapper) Eval 

func (t *DOidWrapper) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DOidWrapper) Format 

func (d *DOidWrapper) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DOidWrapper) IsMax 

func (d *DOidWrapper) IsMax(ctx *EvalContext) bool

IsMax implements the Datum interface.

func (*DOidWrapper) IsMin 

func (d *DOidWrapper) IsMin(ctx *EvalContext) bool

IsMin implements the Datum interface.

func (*DOidWrapper) Max 

func (d *DOidWrapper) Max(ctx *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DOidWrapper) Min 

func (d *DOidWrapper) Min(ctx *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DOidWrapper) Next 

func (d *DOidWrapper) Next(ctx *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DOidWrapper) Prev 

func (d *DOidWrapper) Prev(ctx *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DOidWrapper) ResolvedType 

func (d *DOidWrapper) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*DOidWrapper) Size 

func (d *DOidWrapper) Size() uintptr

Size implements the Datum interface.

func (*DOidWrapper) String 

func (node *DOidWrapper) String() string

func (*DOidWrapper) TypeCheck 

func (d *DOidWrapper) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DOidWrapper) Walk 

func (expr *DOidWrapper) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DString 

type DString string

DString is the string Datum.

func AsDString 

func AsDString(e Expr) (DString, bool)

AsDString attempts to retrieve a DString from an Expr, returning a DString and a flag signifying whether the assertion was successful. The function should be used instead of direct type assertions wherever a *DString wrapped by a *DOidWrapper is possible.

func MustBeDString 

func MustBeDString(e Expr) DString

MustBeDString attempts to retrieve a DString from an Expr, panicking if the assertion fails.

func NewDString 

func NewDString(d string) *DString

NewDString is a helper routine to create a *DString initialized from its argument.

func (*DString) AmbiguousFormat 

func (*DString) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DString) Compare 

func (d *DString) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DString) Eval 

func (t *DString) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DString) Format 

func (d *DString) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DString) IsMax 

func (*DString) IsMax(_ *EvalContext) bool

IsMax implements the Datum interface.

func (*DString) IsMin 

func (d *DString) IsMin(_ *EvalContext) bool

IsMin implements the Datum interface.

func (*DString) Max 

func (d *DString) Max(_ *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DString) Min 

func (d *DString) Min(_ *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DString) Next 

func (d *DString) Next(_ *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DString) Prev 

func (d *DString) Prev(_ *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DString) ResolvedType 

func (*DString) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*DString) Size 

func (d *DString) Size() uintptr

Size implements the Datum interface.

func (*DString) String 

func (node *DString) String() string

func (*DString) TypeCheck 

func (d *DString) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DString) Walk 

func (expr *DString) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DTime 

type DTime timeofday.TimeOfDay

DTime is the time Datum.

func MakeDTime 

func MakeDTime(t timeofday.TimeOfDay) *DTime

MakeDTime creates a DTime from a TimeOfDay.

func ParseDTime 

func ParseDTime(
	ctx ParseTimeContext, s string, precision time.Duration,
) (_ *DTime, dependsOnContext bool, _ error)

ParseDTime parses and returns the *DTime Datum value represented by the provided string, or an error if parsing is unsuccessful.

The dependsOnContext return value indicates if we had to consult the ParseTimeContext (either for the time or the local timezone).

func (*DTime) AmbiguousFormat 

func (*DTime) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DTime) Compare 

func (d *DTime) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DTime) Eval 

func (t *DTime) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DTime) Format 

func (d *DTime) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DTime) IsMax 

func (d *DTime) IsMax(_ *EvalContext) bool

IsMax implements the Datum interface.

func (*DTime) IsMin 

func (d *DTime) IsMin(_ *EvalContext) bool

IsMin implements the Datum interface.

func (*DTime) Max 

func (d *DTime) Max(_ *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DTime) Min 

func (d *DTime) Min(_ *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DTime) Next 

func (d *DTime) Next(ctx *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DTime) Prev 

func (d *DTime) Prev(ctx *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DTime) ResolvedType 

func (*DTime) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*DTime) Round 

func (d *DTime) Round(precision time.Duration) *DTime

Round returns a new DTime to the specified precision.

func (*DTime) Size 

func (d *DTime) Size() uintptr

Size implements the Datum interface.

func (*DTime) String 

func (node *DTime) String() string

func (*DTime) TypeCheck 

func (d *DTime) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DTime) Walk 

func (expr *DTime) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DTimeTZ 

type DTimeTZ struct {
	timetz.TimeTZ
}

DTimeTZ is the time with time zone Datum.

func NewDTimeTZ 

func NewDTimeTZ(t timetz.TimeTZ) *DTimeTZ

NewDTimeTZ creates a DTimeTZ from a timetz.TimeTZ.

func NewDTimeTZFromLocation 

func NewDTimeTZFromLocation(t timeofday.TimeOfDay, loc *time.Location) *DTimeTZ

NewDTimeTZFromLocation creates a DTimeTZ from a TimeOfDay and time.Location.

func NewDTimeTZFromOffset 

func NewDTimeTZFromOffset(t timeofday.TimeOfDay, offsetSecs int32) *DTimeTZ

NewDTimeTZFromOffset creates a DTimeTZ from a TimeOfDay and offset.

func NewDTimeTZFromTime 

func NewDTimeTZFromTime(t time.Time) *DTimeTZ

NewDTimeTZFromTime creates a DTimeTZ from time.Time.

func ParseDTimeTZ 

func ParseDTimeTZ(
	ctx ParseTimeContext, s string, precision time.Duration,
) (_ *DTimeTZ, dependsOnContext bool, _ error)

ParseDTimeTZ parses and returns the *DTime Datum value represented by the provided string, or an error if parsing is unsuccessful.

The dependsOnContext return value indicates if we had to consult the ParseTimeContext (either for the time or the local timezone).

func (*DTimeTZ) AmbiguousFormat 

func (*DTimeTZ) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DTimeTZ) Compare 

func (d *DTimeTZ) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DTimeTZ) Eval 

func (t *DTimeTZ) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DTimeTZ) Format 

func (d *DTimeTZ) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DTimeTZ) IsMax 

func (d *DTimeTZ) IsMax(_ *EvalContext) bool

IsMax implements the Datum interface.

func (*DTimeTZ) IsMin 

func (d *DTimeTZ) IsMin(_ *EvalContext) bool

IsMin implements the Datum interface.

func (*DTimeTZ) Max 

func (d *DTimeTZ) Max(_ *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DTimeTZ) Min 

func (d *DTimeTZ) Min(_ *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DTimeTZ) Next 

func (d *DTimeTZ) Next(ctx *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DTimeTZ) Prev 

func (d *DTimeTZ) Prev(ctx *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DTimeTZ) ResolvedType 

func (*DTimeTZ) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*DTimeTZ) Round 

func (d *DTimeTZ) Round(precision time.Duration) *DTimeTZ

Round returns a new DTimeTZ to the specified precision.

func (*DTimeTZ) Size 

func (d *DTimeTZ) Size() uintptr

Size implements the Datum interface.

func (*DTimeTZ) String 

func (node *DTimeTZ) String() string

func (*DTimeTZ) TypeCheck 

func (d *DTimeTZ) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DTimeTZ) Walk 

func (expr *DTimeTZ) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DTimestamp 

type DTimestamp struct {
	// Time always has UTC location.
	time.Time
}

DTimestamp is the timestamp Datum.

func AsDTimestamp 

func AsDTimestamp(e Expr) (DTimestamp, bool)

AsDTimestamp attempts to retrieve a DTimestamp from an Expr, returning a DTimestamp and a flag signifying whether the assertion was successful. The function should be used instead of direct type assertions wherever a *DTimestamp wrapped by a *DOidWrapper is possible.

func MakeDTimestamp 

func MakeDTimestamp(t time.Time, precision time.Duration) (*DTimestamp, error)

MakeDTimestamp creates a DTimestamp with specified precision.

func MustBeDTimestamp 

func MustBeDTimestamp(e Expr) DTimestamp

MustBeDTimestamp attempts to retrieve a DTimestamp from an Expr, panicking if the assertion fails.

func MustMakeDTimestamp 

func MustMakeDTimestamp(t time.Time, precision time.Duration) *DTimestamp

MustMakeDTimestamp wraps MakeDTimestamp but panics if there is an error. This is intended for testing applications only.

func ParseDTimestamp 

func ParseDTimestamp(
	ctx ParseTimeContext, s string, precision time.Duration,
) (_ *DTimestamp, dependsOnContext bool, _ error)

ParseDTimestamp parses and returns the *DTimestamp Datum value represented by the provided string in UTC, or an error if parsing is unsuccessful.

The dependsOnContext return value indicates if we had to consult the ParseTimeContext (either for the time or the local timezone).

func TimestampToInexactDTimestamp 

func TimestampToInexactDTimestamp(ts hlc.Timestamp) *DTimestamp

TimestampToInexactDTimestamp converts the logical timestamp into an inexact DTimestamp by dropping the logical counter and using the wall time at the microsecond precision.

func (*DTimestamp) AmbiguousFormat 

func (*DTimestamp) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DTimestamp) Compare 

func (d *DTimestamp) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DTimestamp) Eval 

func (t *DTimestamp) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DTimestamp) Format 

func (d *DTimestamp) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DTimestamp) IsMax 

func (d *DTimestamp) IsMax(_ *EvalContext) bool

IsMax implements the Datum interface.

func (*DTimestamp) IsMin 

func (d *DTimestamp) IsMin(_ *EvalContext) bool

IsMin implements the Datum interface.

func (*DTimestamp) Max 

func (d *DTimestamp) Max(_ *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DTimestamp) Min 

func (d *DTimestamp) Min(_ *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DTimestamp) Next 

func (d *DTimestamp) Next(ctx *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DTimestamp) Prev 

func (d *DTimestamp) Prev(ctx *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DTimestamp) ResolvedType 

func (*DTimestamp) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*DTimestamp) Round 

func (d *DTimestamp) Round(precision time.Duration) (*DTimestamp, error)

Round returns a new DTimestamp to the specified precision.

func (*DTimestamp) Size 

func (d *DTimestamp) Size() uintptr

Size implements the Datum interface.

func (*DTimestamp) String 

func (node *DTimestamp) String() string

func (*DTimestamp) TypeCheck 

func (d *DTimestamp) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DTimestamp) Walk 

func (expr *DTimestamp) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DTimestampTZ 

type DTimestampTZ struct {
	time.Time
}

DTimestampTZ is the timestamp Datum that is rendered with session offset.

func AsDTimestampTZ 

func AsDTimestampTZ(e Expr) (DTimestampTZ, bool)

AsDTimestampTZ attempts to retrieve a DTimestampTZ from an Expr, returning a DTimestampTZ and a flag signifying whether the assertion was successful. The function should be used instead of direct type assertions wherever a *DTimestamp wrapped by a *DOidWrapper is possible.

func MakeDTimestampTZ 

func MakeDTimestampTZ(t time.Time, precision time.Duration) (*DTimestampTZ, error)

MakeDTimestampTZ creates a DTimestampTZ with specified precision.

func MakeDTimestampTZFromDate 

func MakeDTimestampTZFromDate(loc *time.Location, d *DDate) (*DTimestampTZ, error)

MakeDTimestampTZFromDate creates a DTimestampTZ from a DDate. This will be equivalent to the midnight of the given zone.

func MustBeDTimestampTZ 

func MustBeDTimestampTZ(e Expr) DTimestampTZ

MustBeDTimestampTZ attempts to retrieve a DTimestampTZ from an Expr, panicking if the assertion fails.

func MustMakeDTimestampTZ 

func MustMakeDTimestampTZ(t time.Time, precision time.Duration) *DTimestampTZ

MustMakeDTimestampTZ wraps MakeDTimestampTZ but panics if there is an error. This is intended for testing applications only.

func ParseDTimestampTZ 

func ParseDTimestampTZ(
	ctx ParseTimeContext, s string, precision time.Duration,
) (_ *DTimestampTZ, dependsOnContext bool, _ error)

ParseDTimestampTZ parses and returns the *DTimestampTZ Datum value represented by the provided string in the provided location, or an error if parsing is unsuccessful.

The dependsOnContext return value indicates if we had to consult the ParseTimeContext (either for the time or the local timezone).

func (*DTimestampTZ) AmbiguousFormat 

func (*DTimestampTZ) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DTimestampTZ) Compare 

func (d *DTimestampTZ) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DTimestampTZ) Eval 

func (t *DTimestampTZ) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DTimestampTZ) EvalAtTimeZone 

func (d *DTimestampTZ) EvalAtTimeZone(ctx *EvalContext, loc *time.Location) (*DTimestamp, error)

EvalAtTimeZone evaluates this TimestampTZ as if it were in the supplied location, returning a timestamp without a timezone.

func (*DTimestampTZ) Format 

func (d *DTimestampTZ) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DTimestampTZ) IsMax 

func (d *DTimestampTZ) IsMax(_ *EvalContext) bool

IsMax implements the Datum interface.

func (*DTimestampTZ) IsMin 

func (d *DTimestampTZ) IsMin(_ *EvalContext) bool

IsMin implements the Datum interface.

func (*DTimestampTZ) Max 

func (d *DTimestampTZ) Max(_ *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DTimestampTZ) Min 

func (d *DTimestampTZ) Min(_ *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DTimestampTZ) Next 

func (d *DTimestampTZ) Next(ctx *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DTimestampTZ) Prev 

func (d *DTimestampTZ) Prev(ctx *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DTimestampTZ) ResolvedType 

func (*DTimestampTZ) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*DTimestampTZ) Round 

func (d *DTimestampTZ) Round(precision time.Duration) (*DTimestampTZ, error)

Round returns a new DTimestampTZ to the specified precision.

func (*DTimestampTZ) Size 

func (d *DTimestampTZ) Size() uintptr

Size implements the Datum interface.

func (*DTimestampTZ) String 

func (node *DTimestampTZ) String() string

func (*DTimestampTZ) TypeCheck 

func (d *DTimestampTZ) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DTimestampTZ) Walk 

func (expr *DTimestampTZ) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DTuple 

type DTuple struct {
	D Datums
	// contains filtered or unexported fields
}

DTuple is the tuple Datum.

func AsDTuple 

func AsDTuple(e Expr) (*DTuple, bool)

AsDTuple attempts to retrieve a *DTuple from an Expr, returning a *DTuple and a flag signifying whether the assertion was successful. The function should be used instead of direct type assertions wherever a *DTuple wrapped by a *DOidWrapper is possible.

func NewDTuple 

func NewDTuple(typ *types.T, d ...Datum) *DTuple

NewDTuple creates a *DTuple with the provided datums. When creating a new DTuple with Datums that are known to be sorted in ascending order, chain this call with DTuple.SetSorted.

func NewDTupleWithLen 

func NewDTupleWithLen(typ *types.T, l int) *DTuple

NewDTupleWithLen creates a *DTuple with the provided length.

func (*DTuple) AmbiguousFormat 

func (*DTuple) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DTuple) AssertSorted 

func (d *DTuple) AssertSorted()

AssertSorted asserts that the DTuple is sorted.

func (*DTuple) Compare 

func (d *DTuple) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DTuple) ContainsNull 

func (d *DTuple) ContainsNull() bool

ContainsNull returns true if the tuple contains NULL, possibly nested inside other tuples. For example, all the following tuples contain NULL: 

(1, 2, NULL)
((1, 1), (2, NULL))
(((1, 1), (2, 2)), ((3, 3), (4, NULL)))

func (*DTuple) Eval 

func (t *DTuple) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DTuple) Format 

func (d *DTuple) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DTuple) IsMax 

func (d *DTuple) IsMax(ctx *EvalContext) bool

IsMax implements the Datum interface.

func (*DTuple) IsMin 

func (d *DTuple) IsMin(ctx *EvalContext) bool

IsMin implements the Datum interface.

func (*DTuple) Max 

func (d *DTuple) Max(ctx *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DTuple) Min 

func (d *DTuple) Min(ctx *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DTuple) Next 

func (d *DTuple) Next(ctx *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DTuple) Normalize 

func (d *DTuple) Normalize(ctx *EvalContext)

Normalize sorts and uniques the datum tuple.

func (*DTuple) Prev 

func (d *DTuple) Prev(ctx *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DTuple) ResolvedType 

func (d *DTuple) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*DTuple) SearchSorted 

func (d *DTuple) SearchSorted(ctx *EvalContext, target Datum) (int, bool)

SearchSorted searches the tuple for the target Datum, returning an int with the same contract as sort.Search and a boolean flag signifying whether the datum was found. It assumes that the DTuple is sorted and panics if it is not.

The target Datum cannot be NULL or a DTuple that contains NULLs (we cannot binary search in this case; for example `(1, NULL) IN ((1, 2), ..)` needs to be

func (*DTuple) SetSorted 

func (d *DTuple) SetSorted() *DTuple

SetSorted sets the sorted flag on the DTuple. This should be used when a DTuple is known to be sorted based on the datums added to it.

func (*DTuple) Size 

func (d *DTuple) Size() uintptr

Size implements the Datum interface.

func (*DTuple) Sorted 

func (d *DTuple) Sorted() bool

Sorted returns true if the tuple is known to be sorted (and contains no NULLs).

func (*DTuple) String 

func (node *DTuple) String() string

func (*DTuple) TypeCheck 

func (d *DTuple) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DTuple) Walk 

func (expr *DTuple) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DUuid 

type DUuid struct {
	uuid.UUID
}

DUuid is the UUID Datum.

func NewDUuid 

func NewDUuid(d DUuid) *DUuid

NewDUuid is a helper routine to create a *DUuid initialized from its argument.

func ParseDUuidFromBytes 

func ParseDUuidFromBytes(b []byte) (*DUuid, error)

ParseDUuidFromBytes parses and returns the *DUuid Datum value represented by the provided input bytes, or an error.

func ParseDUuidFromString 

func ParseDUuidFromString(s string) (*DUuid, error)

ParseDUuidFromString parses and returns the *DUuid Datum value represented by the provided input string, or an error.

func (*DUuid) AmbiguousFormat 

func (*DUuid) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*DUuid) Compare 

func (d *DUuid) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*DUuid) Eval 

func (t *DUuid) Eval(_ *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*DUuid) Format 

func (d *DUuid) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DUuid) IsMax 

func (d *DUuid) IsMax(_ *EvalContext) bool

IsMax implements the Datum interface.

func (*DUuid) IsMin 

func (d *DUuid) IsMin(_ *EvalContext) bool

IsMin implements the Datum interface.

func (*DUuid) Max 

func (*DUuid) Max(_ *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*DUuid) Min 

func (*DUuid) Min(_ *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*DUuid) Next 

func (d *DUuid) Next(_ *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*DUuid) Prev 

func (d *DUuid) Prev(_ *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*DUuid) ResolvedType 

func (*DUuid) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*DUuid) Size 

func (d *DUuid) Size() uintptr

Size implements the Datum interface.

func (*DUuid) String 

func (node *DUuid) String() string

func (*DUuid) TypeCheck 

func (d *DUuid) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface. It is implemented as an idempotent identity function for Datum.

func (*DUuid) Walk 

func (expr *DUuid) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type DatabaseListFlags 

type DatabaseListFlags struct {
	CommonLookupFlags
	// ExplicitPrefix, when set, will cause the returned table names to
	// have an explicit schema and catalog part.
	ExplicitPrefix bool
}

DatabaseListFlags is the flag struct suitable for GetObjectNames().

type DatabaseLookupFlags 

type DatabaseLookupFlags = CommonLookupFlags

DatabaseLookupFlags is the flag struct suitable for GetDatabaseDesc().

type Datum 

type Datum interface {
	TypedExpr

	// AmbiguousFormat indicates whether the result of formatting this Datum can
	// be interpreted into more than one type. Used with
	// fmtFlags.disambiguateDatumTypes.
	AmbiguousFormat() bool

	// Compare returns -1 if the receiver is less than other, 0 if receiver is
	// equal to other and +1 if receiver is greater than other.
	Compare(ctx *EvalContext, other Datum) int

	// Prev returns the previous datum and true, if one exists, or nil and false.
	// The previous datum satisfies the following definition: if the receiver is
	// "b" and the returned datum is "a", then for every compatible datum "x", it
	// holds that "x < b" is true if and only if "x <= a" is true.
	//
	// The return value is undefined if IsMin(_ *EvalContext) returns true.
	//
	// TODO(#12022): for DTuple, the contract is actually that "x < b" (SQL order,
	// where NULL < x is unknown for all x) is true only if "x <= a"
	// (.Compare/encoding order, where NULL <= x is true for all x) is true. This
	// is okay for now: the returned datum is used only to construct a span, which
	// uses .Compare/encoding order and is guaranteed to be large enough by this
	// weaker contract. The original filter expression is left in place to catch
	// false positives.
	Prev(ctx *EvalContext) (Datum, bool)

	// IsMin returns true if the datum is equal to the minimum value the datum
	// type can hold.
	IsMin(ctx *EvalContext) bool

	// Next returns the next datum and true, if one exists, or nil and false
	// otherwise. The next datum satisfies the following definition: if the
	// receiver is "a" and the returned datum is "b", then for every compatible
	// datum "x", it holds that "x > a" is true if and only if "x >= b" is true.
	//
	// The return value is undefined if IsMax(_ *EvalContext) returns true.
	//
	// TODO(#12022): for DTuple, the contract is actually that "x > a" (SQL order,
	// where x > NULL is unknown for all x) is true only if "x >= b"
	// (.Compare/encoding order, where x >= NULL is true for all x) is true. This
	// is okay for now: the returned datum is used only to construct a span, which
	// uses .Compare/encoding order and is guaranteed to be large enough by this
	// weaker contract. The original filter expression is left in place to catch
	// false positives.
	Next(ctx *EvalContext) (Datum, bool)

	// IsMax returns true if the datum is equal to the maximum value the datum
	// type can hold.
	IsMax(ctx *EvalContext) bool

	// Max returns the upper value and true, if one exists, otherwise
	// nil and false. Used By Prev().
	Max(ctx *EvalContext) (Datum, bool)

	// Min returns the lower value, if one exists, otherwise nil and
	// false. Used by Next().
	Min(ctx *EvalContext) (Datum, bool)

	// Size returns a lower bound on the total size of the receiver in bytes,
	// including memory that is pointed at (even if shared between Datum
	// instances) but excluding allocation overhead.
	//
	// It holds for every Datum d that d.Size().
	Size() uintptr
}

Datum represents a SQL value.

func AppendToMaybeNullArray 

func AppendToMaybeNullArray(typ *types.T, left Datum, right Datum) (Datum, error)

AppendToMaybeNullArray appends an element to an array. If the first argument is NULL, an array of one element is created.

func ConcatArrays 

func ConcatArrays(typ *types.T, left Datum, right Datum) (Datum, error)

ConcatArrays concatenates two arrays.

func MakeAllDEnumsInType 

func MakeAllDEnumsInType(typ *types.T) []Datum

MakeAllDEnumsInType generates a slice of all values in an enum. TODO (rohany): In the future, take an option of whether to include 

non-writeable enum values or not.

func MakeDJSON 

func MakeDJSON(d interface{}) (Datum, error)

MakeDJSON returns a JSON value given a Go-style representation of JSON. * JSON null is Go `nil`, * JSON true is Go `true`, * JSON false is Go `false`, * JSON numbers are json.Number | int | int64 | float64, * JSON string is a Go string, * JSON array is a Go []interface{}, * JSON object is a Go map[string]interface{}.

func MatchLikeEscape 

func MatchLikeEscape(
	ctx *EvalContext, unescaped, pattern, escape string, caseInsensitive bool,
) (Datum, error)

MatchLikeEscape matches 'unescaped' with 'pattern' using custom escape character 'escape' which must be either empty (which disables the escape mechanism) or a single unicode character.

func NewDIntVectorFromDArray 

func NewDIntVectorFromDArray(d *DArray) Datum

NewDIntVectorFromDArray is a helper routine to create a *DIntVector (implemented as a *DOidWrapper) initialized from an existing *DArray.

func NewDName 

func NewDName(d string) Datum

NewDName is a helper routine to create a *DName (implemented as a *DOidWrapper) initialized from a string.

func NewDNameFromDString 

func NewDNameFromDString(d *DString) Datum

NewDNameFromDString is a helper routine to create a *DName (implemented as a *DOidWrapper) initialized from an existing *DString.

func NewDOidVectorFromDArray 

func NewDOidVectorFromDArray(d *DArray) Datum

NewDOidVectorFromDArray is a helper routine to create a *DOidVector (implemented as a *DOidWrapper) initialized from an existing *DArray.

func NewDefaultDatum 

func NewDefaultDatum(evalCtx *EvalContext, t *types.T) (d Datum, err error)

NewDefaultDatum returns a default non-NULL datum value for the given type. This is used when updating non-NULL columns that are being added or dropped from a table, and there is no user-defined DEFAULT value available.

func ParseAndRequireString 

func ParseAndRequireString(
	t *types.T, s string, ctx ParseTimeContext,
) (d Datum, dependsOnContext bool, err error)

ParseAndRequireString parses s as type t for simple types. Arrays and collated strings are not handled.

The dependsOnContext return value indicates if we had to consult the ParseTimeContext (either for the time or the local timezone).

func ParseDJSON 

func ParseDJSON(s string) (Datum, error)

ParseDJSON takes a string of JSON and returns a DJSON value.

func PerformCast 

func PerformCast(ctx *EvalContext, d Datum, t *types.T) (Datum, error)

PerformCast performs a cast from the provided Datum to the specified types.T.

func PickFromTuple 

func PickFromTuple(ctx *EvalContext, greatest bool, args Datums) (Datum, error)

PickFromTuple picks the greatest (or least value) from a tuple.

func PrependToMaybeNullArray 

func PrependToMaybeNullArray(typ *types.T, left Datum, right Datum) (Datum, error)

PrependToMaybeNullArray prepends an element in the front of an arrray. If the argument is NULL, an array of one element is created.

func SampleDatum 

func SampleDatum(t *types.T) Datum

SampleDatum is intended to be a more lightweight version of RandDatum for when you just need one consistent example of a datum.

func SimilarToEscape 

func SimilarToEscape(ctx *EvalContext, unescaped, pattern, escape string) (Datum, error)

SimilarToEscape checks if 'unescaped' is SIMILAR TO 'pattern' using custom escape token 'escape' which must be either empty (which disables the escape mechanism) or a single unicode character.

func TimestampDifference 

func TimestampDifference(ctx *EvalContext, start, end Datum) (Datum, error)

TimestampDifference computes the interval difference between two TimestampTZ datums. The result is a DInterval. The caller must ensure that the arguments are of the proper Datum type.

func UnwrapDatum 

func UnwrapDatum(evalCtx *EvalContext, d Datum) Datum

UnwrapDatum returns the base Datum type for a provided datum, stripping an *DOidWrapper if present. This is useful for cases like type switches, where type aliases should be ignored.

type Datums 

type Datums []Datum

Datums is a slice of Datum values.

func (Datums) Compare 

func (d Datums) Compare(evalCtx *EvalContext, other Datums) int

Compare does a lexicographical comparison and returns -1 if the receiver is less than other, 0 if receiver is equal to other and +1 if receiver is greater than other.

func (*Datums) Format 

func (d *Datums) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (Datums) IsDistinctFrom 

func (d Datums) IsDistinctFrom(evalCtx *EvalContext, other Datums) bool

IsDistinctFrom checks to see if two datums are distinct from each other. Any change in value is considered distinct, however, a NULL value is NOT considered distinct from another NULL value.

func (Datums) Len 

func (d Datums) Len() int

Len returns the number of Datum values.

func (*Datums) String 

func (node *Datums) String() string

type Deallocate 

type Deallocate struct {
	Name Name // empty for ALL
}

Deallocate represents a DEALLOCATE statement.

func (*Deallocate) Format 

func (node *Deallocate) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Deallocate) StatementTag 

func (n *Deallocate) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Deallocate) StatementType 

func (*Deallocate) StatementType() StatementType

StatementType implements the Statement interface.

func (*Deallocate) String 

func (n *Deallocate) String() string

type DefaultVal 

type DefaultVal struct{}

DefaultVal represents the DEFAULT expression.

func (DefaultVal) Eval 

func (expr DefaultVal) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (DefaultVal) Format 

func (node DefaultVal) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (DefaultVal) ResolvedType 

func (DefaultVal) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (DefaultVal) String 

func (node DefaultVal) String() string

func (DefaultVal) TypeCheck 

func (expr DefaultVal) TypeCheck(
	_ context.Context, _ *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (DefaultVal) Walk 

func (expr DefaultVal) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type Delete 

type Delete struct {
	With      *With
	Table     TableExpr
	Where     *Where
	OrderBy   OrderBy
	Limit     *Limit
	Returning ReturningClause
}

Delete represents a DELETE statement.

func (*Delete) Format 

func (node *Delete) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Delete) StatementTag 

func (*Delete) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Delete) StatementType 

func (n *Delete) StatementType() StatementType

StatementType implements the Statement interface.

func (*Delete) String 

func (n *Delete) String() string

type DescriptorCoverage 

type DescriptorCoverage int32

DescriptorCoverage specifies whether or not a subset of descriptors were requested or if all the descriptors were requested, so all the descriptors are covered in a given backup. 

const (
	// RequestedDescriptors table coverage means that the backup is not
	// guaranteed to have all of the cluster data. This can be accomplished by
	// backing up a specific subset of tables/databases. Note that even if all
	// of the tables and databases have been included in the backup manually, a
	// backup is not said to have complete table coverage unless it was created
	// by a `BACKUP TO` command.
	RequestedDescriptors DescriptorCoverage = iota
	// AllDescriptors table coverage means that backup is guaranteed to have all the
	// relevant data in the cluster. These can only be created by running a
	// full cluster backup with `BACKUP TO`.
	AllDescriptors
)

type DesiredObjectKind 

type DesiredObjectKind int

DesiredObjectKind represents what kind of object is desired in a name resolution attempt. 

const (
	// TableObject is used when a table-like object is desired from resolution.
	TableObject DesiredObjectKind = iota
	// TypeObject is used when a type-like object is desired from resolution.
	TypeObject
)

type Direction 

type Direction int8

Direction for ordering results. 

const (
	DefaultDirection Direction = iota
	Ascending
	Descending
)

Direction values.

func (Direction) String 

func (d Direction) String() string

type Discard 

type Discard struct {
	Mode DiscardMode
}

Discard represents a DISCARD statement.

func (*Discard) Format 

func (node *Discard) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Discard) StatementTag 

func (*Discard) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Discard) StatementType 

func (*Discard) StatementType() StatementType

StatementType implements the Statement interface.

func (*Discard) String 

func (node *Discard) String() string

String implements the Statement interface.

type DiscardMode 

type DiscardMode int

DiscardMode is an enum of the various discard modes. 

const (
	// DiscardModeAll represents a DISCARD ALL statement.
	DiscardModeAll DiscardMode = iota
)

type DistinctOn 

type DistinctOn []Expr

DistinctOn represents a DISTINCT ON clause.

func (*DistinctOn) Format 

func (node *DistinctOn) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type DropBehavior 

type DropBehavior int

DropBehavior represents options for dropping schema elements. 

const (
	DropDefault DropBehavior = iota
	DropRestrict
	DropCascade
)

DropBehavior values.

func (DropBehavior) String 

func (d DropBehavior) String() string

type DropDatabase 

type DropDatabase struct {
	Name         Name
	IfExists     bool
	DropBehavior DropBehavior
}

DropDatabase represents a DROP DATABASE statement.

func (*DropDatabase) Format 

func (node *DropDatabase) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DropDatabase) StatementTag 

func (*DropDatabase) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*DropDatabase) StatementType 

func (*DropDatabase) StatementType() StatementType

StatementType implements the Statement interface.

func (*DropDatabase) String 

func (n *DropDatabase) String() string

type DropIndex 

type DropIndex struct {
	IndexList    TableIndexNames
	IfExists     bool
	DropBehavior DropBehavior
	Concurrently bool
}

DropIndex represents a DROP INDEX statement.

func (*DropIndex) Format 

func (node *DropIndex) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DropIndex) StatementTag 

func (*DropIndex) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*DropIndex) StatementType 

func (*DropIndex) StatementType() StatementType

StatementType implements the Statement interface.

func (*DropIndex) String 

func (n *DropIndex) String() string

type DropRole 

type DropRole struct {
	Names    Exprs
	IsRole   bool
	IfExists bool
}

DropRole represents a DROP ROLE statement

func (*DropRole) Format 

func (node *DropRole) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DropRole) StatementTag 

func (*DropRole) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*DropRole) StatementType 

func (*DropRole) StatementType() StatementType

StatementType implements the Statement interface.

func (*DropRole) String 

func (n *DropRole) String() string

type DropSequence 

type DropSequence struct {
	Names        TableNames
	IfExists     bool
	DropBehavior DropBehavior
}

DropSequence represents a DROP SEQUENCE statement.

func (*DropSequence) Format 

func (node *DropSequence) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DropSequence) StatementTag 

func (*DropSequence) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*DropSequence) StatementType 

func (*DropSequence) StatementType() StatementType

StatementType implements the Statement interface.

func (*DropSequence) String 

func (n *DropSequence) String() string

type DropTable 

type DropTable struct {
	Names        TableNames
	IfExists     bool
	DropBehavior DropBehavior
}

DropTable represents a DROP TABLE statement.

func (*DropTable) Format 

func (node *DropTable) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DropTable) StatementTag 

func (*DropTable) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*DropTable) StatementType 

func (*DropTable) StatementType() StatementType

StatementType implements the Statement interface.

func (*DropTable) String 

func (n *DropTable) String() string

type DropType 

type DropType struct {
	Names        []*UnresolvedObjectName
	IfExists     bool
	DropBehavior DropBehavior
}

DropType represents a DROP TYPE command.

func (*DropType) Format 

func (node *DropType) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DropType) StatementTag 

func (*DropType) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*DropType) StatementType 

func (*DropType) StatementType() StatementType

StatementType implements the Statement interface.

func (*DropType) String 

func (n *DropType) String() string

type DropView 

type DropView struct {
	Names        TableNames
	IfExists     bool
	DropBehavior DropBehavior
}

DropView represents a DROP VIEW statement.

func (*DropView) Format 

func (node *DropView) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*DropView) StatementTag 

func (*DropView) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*DropView) StatementType 

func (*DropView) StatementType() StatementType

StatementType implements the Statement interface.

func (*DropView) String 

func (n *DropView) String() string

type EvalContext 

type EvalContext struct {
	// Session variables. This is a read-only copy of the values owned by the
	// Session.
	SessionData *sessiondata.SessionData
	// TxnState is a string representation of the current transactional state.
	TxnState string
	// TxnReadOnly specifies if the current transaction is read-only.
	TxnReadOnly bool
	TxnImplicit bool

	ClusterID   uuid.UUID
	ClusterName string

	// The statement timestamp. May be different for every statement.
	// Used for statement_timestamp().
	StmtTimestamp time.Time
	// The transaction timestamp. Needs to stay stable for the lifetime
	// of a transaction. Used for now(), current_timestamp(),
	// transaction_timestamp() and the like.
	TxnTimestamp time.Time

	// Placeholders relates placeholder names to their type and, later, value.
	// This pointer should always be set to the location of the PlaceholderInfo
	// in the corresponding SemaContext during normal execution. Placeholders are
	// available during Eval to permit lookup of a particular placeholder's
	// underlying datum, if available.
	Placeholders *PlaceholderInfo

	// Annotations augments the AST with extra information. This pointer should
	// always be set to the location of the Annotations in the corresponding
	// SemaContext.
	Annotations *Annotations

	// IVarContainer is used to evaluate IndexedVars.
	IVarContainer IndexedVarContainer

	// Context holds the context in which the expression is evaluated.
	Context context.Context

	// InternalExecutor gives access to an executor to be used for running
	// "internal" statements. It may seem bizarre that "expression evaluation" may
	// need to run a statement, and yet many builtin functions do it.
	// Note that the executor will be "session-bound" - it will inherit session
	// variables from a parent session.
	InternalExecutor InternalExecutor

	Planner EvalPlanner

	PrivilegedAccessor PrivilegedAccessor

	SessionAccessor EvalSessionAccessor

	ClientNoticeSender ClientNoticeSender

	Sequence SequenceOperators

	Tenant TenantOperator

	// TypeResolver is a type resolver that can be used during execution.
	TypeResolver TypeReferenceResolver

	ReCache *RegexpCache

	// TODO(mjibson): remove prepareOnly in favor of a 2-step prepare-exec solution
	// that is also able to save the plan to skip work during the exec step.
	PrepareOnly bool

	// SkipNormalize indicates whether expressions should be normalized
	// (false) or not (true).  It is set to true conditionally by
	// EXPLAIN(TYPES[, NORMALIZE]).
	SkipNormalize bool

	CollationEnv CollationEnvironment

	TestingKnobs EvalContextTestingKnobs

	Mon *mon.BytesMonitor

	// SingleDatumAggMemAccount is a memory account that all aggregate builtins
	// that store a single datum will share to account for the memory needed to
	// perform the aggregation (i.e. memory not reported by AggregateFunc.Size
	// method). This memory account exists so that such aggregate functions
	// could "batch" their reservations - otherwise, we end up a situation
	// where each aggregate function struct grows its own memory account by
	// tiny amount, yet the account reserves a lot more resulting in
	// significantly overestimating the memory usage.
	SingleDatumAggMemAccount *mon.BoundAccount
	// contains filtered or unexported fields
}

EvalContext defines the context in which to evaluate an expression, allowing the retrieval of state such as the node ID or statement start time.

ATTENTION: Some fields from this struct (particularly, but not exclusively, from SessionData) are also represented in execinfrapb.EvalContext. Whenever something that affects DistSQL execution is added, it needs to be marshaled through that proto too. TODO(andrei): remove or limit the duplication.

NOTE(andrei): EvalContext is dusty; it started as a collection of fields needed by expression evaluation, but it has grown quite large; some of the things in it don't seem to belong in this low-level package (e.g. Planner). In the sql package it is embedded by extendedEvalContext, which adds some more fields from the sql package. Through that extendedEvalContext, this struct now generally used by planNodes.

func (*EvalContext) Copy 

func (ctx *EvalContext) Copy() *EvalContext

Copy returns a deep copy of ctx.

func (*EvalContext) Ctx 

func (ctx *EvalContext) Ctx() context.Context

Ctx returns the session's context.

func (*EvalContext) GetLocation 

func (ctx *EvalContext) GetLocation() *time.Location

GetLocation returns the session timezone.

func (*EvalContext) GetRelativeParseTime 

func (ctx *EvalContext) GetRelativeParseTime() time.Time

GetRelativeParseTime implements ParseTimeContext.

func (*EvalContext) GetStmtTimestamp 

func (ctx *EvalContext) GetStmtTimestamp() time.Time

GetStmtTimestamp retrieves the current statement timestamp as per the evaluation context. The timestamp is guaranteed to be nonzero.

func (*EvalContext) GetTxnTime 

func (ctx *EvalContext) GetTxnTime(precision time.Duration) *DTimeTZ

GetTxnTime retrieves the current transaction time as per the evaluation context.

func (*EvalContext) GetTxnTimeNoZone 

func (ctx *EvalContext) GetTxnTimeNoZone(precision time.Duration) *DTime

GetTxnTimeNoZone retrieves the current transaction time as per the evaluation context.

func (*EvalContext) GetTxnTimestamp 

func (ctx *EvalContext) GetTxnTimestamp(precision time.Duration) *DTimestampTZ

GetTxnTimestamp retrieves the current transaction timestamp as per the evaluation context. The timestamp is guaranteed to be nonzero.

func (*EvalContext) GetTxnTimestampNoZone 

func (ctx *EvalContext) GetTxnTimestampNoZone(precision time.Duration) *DTimestamp

GetTxnTimestampNoZone retrieves the current transaction timestamp as per the evaluation context. The timestamp is guaranteed to be nonzero.

func (*EvalContext) HasPlaceholders 

func (ctx *EvalContext) HasPlaceholders() bool

HasPlaceholders returns true if this EvalContext's placeholders have been assigned. Will be false during Prepare.

func (*EvalContext) NormalizeExpr 

func (ctx *EvalContext) NormalizeExpr(typedExpr TypedExpr) (TypedExpr, error)

NormalizeExpr normalizes a typed expression, simplifying where possible, but guaranteeing that the result of evaluating the expression is unchanged and that resulting expression tree is still well-typed. Example normalizations: 

(a)                   -> a
a = 1 + 1             -> a = 2
a + 1 = 2             -> a = 1
a BETWEEN b AND c     -> (a >= b) AND (a <= c)
a NOT BETWEEN b AND c -> (a < b) OR (a > c)

func (*EvalContext) PopIVarContainer 

func (ctx *EvalContext) PopIVarContainer()

PopIVarContainer discards the current IVarContainer on the EvalContext, replacing it with an older one.

func (*EvalContext) PushIVarContainer 

func (ctx *EvalContext) PushIVarContainer(c IndexedVarContainer)

PushIVarContainer replaces the current IVarContainer with a different one - pushing the current one onto a stack to be replaced later once PopIVarContainer is called.

func (*EvalContext) SetStmtTimestamp 

func (ctx *EvalContext) SetStmtTimestamp(ts time.Time)

SetStmtTimestamp sets the corresponding timestamp in the EvalContext.

func (*EvalContext) SetTxnTimestamp 

func (ctx *EvalContext) SetTxnTimestamp(ts time.Time)

SetTxnTimestamp sets the corresponding timestamp in the EvalContext.

func (*EvalContext) Stop 

func (ctx *EvalContext) Stop(c context.Context)

Stop closes out the EvalContext and must be called once it is no longer in use.

type EvalContextTestingKnobs 

type EvalContextTestingKnobs struct {
	// AssertFuncExprReturnTypes indicates whether FuncExpr evaluations
	// should assert that the returned Datum matches the expected
	// ReturnType of the function.
	AssertFuncExprReturnTypes bool
	// AssertUnaryExprReturnTypes indicates whether UnaryExpr evaluations
	// should assert that the returned Datum matches the expected
	// ReturnType of the function.
	AssertUnaryExprReturnTypes bool
	// AssertBinaryExprReturnTypes indicates whether BinaryExpr
	// evaluations should assert that the returned Datum matches the
	// expected ReturnType of the function.
	AssertBinaryExprReturnTypes bool
	// DisableOptimizerRuleProbability is the probability that any given
	// transformation rule in the optimizer is disabled.
	DisableOptimizerRuleProbability float64
	// OptimizerCostPerturbation is used to randomly perturb the estimated
	// cost of each expression in the query tree for the purpose of creating
	// alternate query plans in the optimizer.
	OptimizerCostPerturbation float64

	CallbackGenerators map[string]*CallbackValueGenerator
}

EvalContextTestingKnobs contains test knobs.

func (*EvalContextTestingKnobs) ModuleTestingKnobs 

func (*EvalContextTestingKnobs) ModuleTestingKnobs()

ModuleTestingKnobs is part of the base.ModuleTestingKnobs interface.

type EvalDatabase 

type EvalDatabase interface {
	// ParseQualifiedTableName parses a SQL string of the form
	// `[ database_name . ] [ schema_name . ] table_name`.
	// NB: this is deprecated! Use parser.ParseQualifiedTableName when possible.
	ParseQualifiedTableName(sql string) (*TableName, error)

	// ResolveTableName expands the given table name and
	// makes it point to a valid object.
	// If the database name is not given, it uses the search path to find it, and
	// sets it on the returned TableName.
	// It returns the ID of the resolved table, and an error if the table doesn't exist.
	ResolveTableName(ctx context.Context, tn *TableName) (ID, error)

	// LookupSchema looks up the schema with the given name in the given
	// database.
	LookupSchema(ctx context.Context, dbName, scName string) (found bool, scMeta SchemaMeta, err error)
}

EvalDatabase consists of functions that reference the session database and is to be used from EvalContext.

type EvalPlanner 

type EvalPlanner interface {
	EvalDatabase
	// ParseType parses a column type.
	ParseType(sql string) (*types.T, error)

	// EvalSubquery returns the Datum for the given subquery node.
	EvalSubquery(expr *Subquery) (Datum, error)
}

EvalPlanner is a limited planner that can be used from EvalContext.

type EvalSessionAccessor 

type EvalSessionAccessor interface {
	// SetConfig sets a session variable to a new value.
	//
	// This interface only supports strings as this is sufficient for
	// pg_catalog.set_config().
	SetSessionVar(ctx context.Context, settingName, newValue string) error

	// GetSessionVar retrieves the current value of a session variable.
	GetSessionVar(ctx context.Context, settingName string, missingOk bool) (bool, string, error)

	// HasAdminRole returns true iff the current session user has the admin role.
	HasAdminRole(ctx context.Context) (bool, error)
}

EvalSessionAccessor is a limited interface to access session variables.

type Execute 

type Execute struct {
	Name   Name
	Params Exprs
	// DiscardRows is set when we want to throw away all the rows rather than
	// returning for client (used for testing and benchmarking).
	DiscardRows bool
}

Execute represents an EXECUTE statement.

func (*Execute) Format 

func (node *Execute) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Execute) StatementTag 

func (*Execute) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Execute) StatementType 

func (*Execute) StatementType() StatementType

StatementType implements the Statement interface.

func (*Execute) String 

func (n *Execute) String() string

type Explain 

type Explain struct {
	ExplainOptions

	// Statement is the statement being EXPLAINed.
	Statement Statement
}

Explain represents an EXPLAIN statement.

func (*Explain) Format 

func (node *Explain) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Explain) StatementTag 

func (*Explain) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Explain) StatementType 

func (*Explain) StatementType() StatementType

StatementType implements the Statement interface.

func (*Explain) String 

func (n *Explain) String() string

type ExplainAnalyzeDebug 

type ExplainAnalyzeDebug struct {
	Statement Statement
}

ExplainAnalyzeDebug represents an EXPLAIN ANALYZE (DEBUG) statement. It is a different node type than Explain to allow easier special treatment in the SQL layer.

func (*ExplainAnalyzeDebug) Format 

func (node *ExplainAnalyzeDebug) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ExplainAnalyzeDebug) StatementTag 

func (*ExplainAnalyzeDebug) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ExplainAnalyzeDebug) StatementType 

func (*ExplainAnalyzeDebug) StatementType() StatementType

StatementType implements the Statement interface.

func (*ExplainAnalyzeDebug) String 

func (n *ExplainAnalyzeDebug) String() string

type ExplainFlag 

type ExplainFlag uint8

ExplainFlag is a modifier in an EXPLAIN statement (like VERBOSE). 

const (
	ExplainFlagVerbose ExplainFlag = 1 + iota
	ExplainFlagTypes
	ExplainFlagAnalyze
	ExplainFlagEnv
	ExplainFlagCatalog
	ExplainFlagDebug
)

Explain flags.

func (ExplainFlag) String 

func (f ExplainFlag) String() string

type ExplainMode 

type ExplainMode uint8

ExplainMode indicates the mode of the explain. Currently there are two modes: PLAN (the default) and DISTSQL. 

const (
	// ExplainPlan shows information about the planNode tree for a query.
	ExplainPlan ExplainMode = 1 + iota

	// ExplainDistSQL shows the physical distsql plan for a query and whether a
	// query would be run in "auto" DISTSQL mode. See sql/explain_distsql.go for
	// details. If the ANALYZE option is included, the plan is also executed and
	// execution statistics are collected and shown in the diagram.
	ExplainDistSQL

	// ExplainOpt shows the optimized relational expression (from the cost-based
	// optimizer).
	ExplainOpt

	// ExplainVec shows the physical vectorized plan for a query and whether a
	// query would be run in "auto" vectorized mode.
	ExplainVec
)

func (ExplainMode) String 

func (m ExplainMode) String() string

type ExplainOptions 

type ExplainOptions struct {
	Mode  ExplainMode
	Flags [numExplainFlags + 1]bool
}

ExplainOptions contains information about the options passed to an EXPLAIN statement.

type Export 

type Export struct {
	Query      *Select
	FileFormat string
	File       Expr
	Options    KVOptions
}

Export represents a EXPORT statement.

func (*Export) Format 

func (node *Export) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Export) StatementTag 

func (*Export) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Export) StatementType 

func (*Export) StatementType() StatementType

StatementType implements the Statement interface.

func (*Export) String 

func (n *Export) String() string

type Expr 

type Expr interface {
	fmt.Stringer
	NodeFormatter
	// Walk recursively walks all children using WalkExpr. If any children are changed, it returns a
	// copy of this node updated to point to the new children. Otherwise the receiver is returned.
	// For childless (leaf) Exprs, its implementation is empty.
	Walk(Visitor) Expr
	// TypeCheck transforms the Expr into a well-typed TypedExpr, which further permits
	// evaluation and type introspection, or an error if the expression cannot be well-typed.
	// When type checking is complete, if no error was reported, the expression and all
	// sub-expressions will be guaranteed to be well-typed, meaning that the method effectively
	// maps the Expr tree into a TypedExpr ast.
	//
	// The semaCtx parameter defines the context in which to perform type checking.
	// The desired parameter hints the desired type that the method's caller wants from
	// the resulting TypedExpr. It is not valid to call TypeCheck with a nil desired
	// type. Instead, call it with wildcard type types.Any if no specific type is
	// desired. This restriction is also true of most methods and functions related
	// to type checking.
	TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error)
}

Expr represents an expression.

func SimpleVisit 

func SimpleVisit(expr Expr, preFn SimpleVisitFn) (Expr, error)

SimpleVisit is a convenience wrapper for visitors that only have VisitPre code and don't return any results except an error. The given function is called in VisitPre for every node. The visitor stops as soon as an error is returned.

func StripMemoizedFuncs 

func StripMemoizedFuncs(expr Expr) Expr

StripMemoizedFuncs strips memoized function references from expression trees. This is necessary to permit equality checks using reflect.DeepEqual. Used in testing.

func StripParens 

func StripParens(expr Expr) Expr

StripParens strips any parentheses surrounding an expression and returns the inner expression. For instance: 

 1   -> 1
(1)  -> 1

((1)) -> 1

func WalkExpr 

func WalkExpr(v Visitor, expr Expr) (newExpr Expr, changed bool)

WalkExpr traverses the nodes in an expression.

NOTE: Do not count on the walkStmt/WalkExpr machinery to visit all expressions contained in a query. Only a sub-set of all expressions are found by walkStmt and subsequently traversed. See the comment below on walkStmt for details.

type Exprs 

type Exprs []Expr

Exprs represents a list of value expressions. It's not a valid expression because it's not parenthesized.

func (*Exprs) Format 

func (node *Exprs) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Exprs) String 

func (node *Exprs) String() string

type FamilyTableDef 

type FamilyTableDef struct {
	Name    Name
	Columns NameList
}

FamilyTableDef represents a family definition within a CREATE TABLE statement.

func (*FamilyTableDef) Format 

func (node *FamilyTableDef) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type FmtCtx 

type FmtCtx struct {
	bytes.Buffer
	// contains filtered or unexported fields
}

FmtCtx is suitable for passing to Format() methods. It also exposes the underlying bytes.Buffer interface for convenience.

FmtCtx cannot be copied by value.

func NewFmtCtx 

func NewFmtCtx(f FmtFlags) *FmtCtx

NewFmtCtx creates a FmtCtx; only flags that don't require Annotations can be used.

func NewFmtCtxEx 

func NewFmtCtxEx(f FmtFlags, ann *Annotations) *FmtCtx

NewFmtCtxEx creates a FmtCtx.

func (*FmtCtx) Close 

func (ctx *FmtCtx) Close()

Close releases a FmtCtx for reuse. Closing a FmtCtx is not required, but is recommended for performance-sensitive paths.

func (*FmtCtx) CloseAndGetString 

func (ctx *FmtCtx) CloseAndGetString() string

CloseAndGetString combines Close() and String().

func (*FmtCtx) FormatName 

func (ctx *FmtCtx) FormatName(s string)

FormatName formats a string as a name.

Note: prefer FormatNameP below when the string is already on the heap.

func (*FmtCtx) FormatNameP 

func (ctx *FmtCtx) FormatNameP(s *string)

FormatNameP formats a string reference as a name.

func (*FmtCtx) FormatNode 

func (ctx *FmtCtx) FormatNode(n NodeFormatter)

FormatNode recurses into a node for pretty-printing. Flag-driven special cases can hook into this.

func (*FmtCtx) FormatTypeReference 

func (ctx *FmtCtx) FormatTypeReference(ref ResolvableTypeReference)

FormatTypeReference formats a ResolvableTypeReference.

func (*FmtCtx) HasFlags 

func (ctx *FmtCtx) HasFlags(f FmtFlags) bool

HasFlags returns true iff the given flags are set in the formatter context.

func (*FmtCtx) Printf 

func (ctx *FmtCtx) Printf(f string, args ...interface{})

Printf calls fmt.Fprintf on the linked bytes.Buffer. It is provided for convenience, to avoid having to call fmt.Fprintf(&ctx.Buffer, ...).

Note: DO NOT USE THIS TO INTERPOLATE %s ON NodeFormatter OBJECTS. This would call the String() method on them and would fail to reuse the same bytes buffer (and waste allocations). Instead use ctx.FormatNode().

func (*FmtCtx) SetIndexedTypeFormat 

func (ctx *FmtCtx) SetIndexedTypeFormat(fn func(*FmtCtx, *IDTypeReference))

SetIndexedTypeFormat modifies FmtCtx to customize the printing of IDTypeReferences using the provided function.

func (*FmtCtx) SetIndexedVarFormat 

func (ctx *FmtCtx) SetIndexedVarFormat(fn func(ctx *FmtCtx, idx int))

SetIndexedVarFormat modifies FmtCtx to customize the printing of IndexedVars using the provided function.

func (*FmtCtx) SetPlaceholderFormat 

func (ctx *FmtCtx) SetPlaceholderFormat(placeholderFn func(_ *FmtCtx, _ *Placeholder))

SetPlaceholderFormat modifies FmtCtx to customize the printing of StarDatums using the provided function.

func (*FmtCtx) SetReformatTableNames 

func (ctx *FmtCtx) SetReformatTableNames(tableNameFmt func(*FmtCtx, *TableName))

SetReformatTableNames modifies FmtCtx to to substitute the printing of table names using the provided function.

func (*FmtCtx) WithFlags 

func (ctx *FmtCtx) WithFlags(flags FmtFlags, fn func())

WithFlags changes the flags in the FmtCtx, runs the given function, then restores the old flags.

func (*FmtCtx) WithPlaceholderFormat 

func (ctx *FmtCtx) WithPlaceholderFormat(placeholderFn func(_ *FmtCtx, _ *Placeholder), fn func())

WithPlaceholderFormat changes the placeholder formatting function, calls the given function, then restores the placeholder function.

func (*FmtCtx) WithReformatTableNames 

func (ctx *FmtCtx) WithReformatTableNames(tableNameFmt func(*FmtCtx, *TableName), fn func())

WithReformatTableNames modifies FmtCtx to to substitute the printing of table names using the provided function, calls fn, then restores the original table formatting.

type FmtFlags 

type FmtFlags int

FmtFlags carries options for the pretty-printer. 

const (
	// FmtSimple instructs the pretty-printer to produce
	// a straightforward representation.
	FmtSimple FmtFlags = 0

	// FmtBareStrings instructs the pretty-printer to print strings and
	// other values without wrapping quotes. If the value is a SQL
	// string, the quotes will only be omitted if the string contains no
	// special characters. If it does contain special characters, the
	// string will be escaped and enclosed in e'...' regardless of
	// whether FmtBareStrings is specified. See FmtRawStrings below for
	// an alternative.
	FmtBareStrings FmtFlags = FmtFlags(lex.EncBareStrings)

	// FmtBareIdentifiers instructs the pretty-printer to print
	// identifiers without wrapping quotes in any case.
	FmtBareIdentifiers FmtFlags = FmtFlags(lex.EncBareIdentifiers)

	// FmtShowPasswords instructs the pretty-printer to not suppress passwords.
	// If not set, passwords are replaced by *****.
	FmtShowPasswords FmtFlags = FmtFlags(lex.EncFirstFreeFlagBit) << iota

	// FmtShowTypes instructs the pretty-printer to
	// annotate expressions with their resolved types.
	FmtShowTypes

	// FmtHideConstants instructs the pretty-printer to produce a
	// representation that does not disclose query-specific data. It
	// also shorten long lists in tuples, VALUES and array expressions.
	FmtHideConstants

	// FmtAnonymize instructs the pretty-printer to remove
	// any name but function names.
	// TODO(knz): temporary until a better solution is found for #13968
	FmtAnonymize

	// FmtAlwaysQualifyTableNames instructs the pretty-printer to
	// qualify table names, even if originally omitted.
	// Requires Annotations in the formatting context.
	FmtAlwaysQualifyTableNames

	// FmtAlwaysGroupExprs instructs the pretty-printer to enclose
	// sub-expressions between parentheses.
	// Used for testing.
	FmtAlwaysGroupExprs

	// FmtShowTableAliases reveals the table aliases.
	FmtShowTableAliases

	// FmtSymbolicSubqueries indicates that subqueries must be pretty-printed
	// using numeric notation (@S123).
	FmtSymbolicSubqueries

	// FmtParsableNumerics produces decimal and float representations
	// that are always parsable, even if they require a string
	// representation like -Inf. Negative values are preserved "inside"
	// the numeric by enclosing them within parentheses.
	FmtParsableNumerics

	// FmtPGAttrdefAdbin is used to produce expressions formatted in a way that's
	// as close as possible to what clients expect to live in the pg_attrdef.adbin
	// column. Specifically, this strips type annotations, since Postgres doesn't
	// know what those are.
	FmtPGAttrdefAdbin

	// FmtPGIndexDef is used to produce CREATE INDEX statements that are
	// compatible with pg_get_indexdef.
	FmtPGIndexDef
)

Basic bit definitions for the FmtFlags bitmask. 

const (
	// FmtPgwireText instructs the pretty-printer to use
	// a pg-compatible conversion to strings. See comments
	// in pgwire_encode.go.
	FmtPgwireText FmtFlags = fmtPgwireFormat | FmtFlags(lex.EncBareStrings)

	// FmtParsable instructs the pretty-printer to produce a representation that
	// can be parsed into an equivalent expression. If there is a chance that the
	// formatted data will be stored durably on disk or sent to other nodes,
	// then this formatting directive is not appropriate, and FmtSerializable
	// should be used instead.
	FmtParsable FmtFlags = fmtDisambiguateDatumTypes | FmtParsableNumerics

	// FmtSerializable instructs the pretty-printer to produce a representation
	// for expressions that can be serialized to disk. It serializes user defined
	// types using representations that are stable across changes of the type
	// itself. This should be used when serializing expressions that will be
	// stored on disk, like DEFAULT expressions of columns.
	FmtSerializable FmtFlags = FmtParsable | fmtStaticallyFormatUserDefinedTypes

	// FmtCheckEquivalence instructs the pretty-printer to produce a representation
	// that can be used to check equivalence of expressions. Specifically:
	//  - IndexedVars are formatted using symbolic notation (to disambiguate
	//    columns).
	//  - datum types are disambiguated with explicit type
	//    annotations. This is necessary because datums of different types
	//    can otherwise be formatted to the same string: (for example the
	//    DDecimal 1 and the DInt 1).
	//  - user defined types and datums of user defined types are formatted
	//    using static representations to avoid name resolution and invalidation
	//    due to changes in the underlying type.
	FmtCheckEquivalence FmtFlags = fmtSymbolicVars |
		fmtDisambiguateDatumTypes |
		FmtParsableNumerics |
		fmtStaticallyFormatUserDefinedTypes

	// FmtArrayToString is a special composite flag suitable
	// for the output of array_to_string(). This de-quotes
	// the strings enclosed in the array and skips the normal escaping
	// of strings. Special characters are hex-escaped.
	FmtArrayToString FmtFlags = FmtBareStrings | fmtRawStrings

	// FmtExport, if set, formats datums in a raw form suitable for
	// EXPORT, e.g. suitable for output into a CSV file. The intended
	// goal for this flag is to ensure values can be read back using the
	// ParseDatumStringAs() / ParseStringas() functions (IMPORT).
	//
	// We do not use FmtParsable for this purpose because FmtParsable
	// intends to preserve all the information useful to CockroachDB
	// internally, at the expense of readability by 3rd party tools.
	//
	// We also separate this set of flag from fmtArrayToString
	// because the behavior of array_to_string() is fixed for compatibility
	// with PostgreSQL, whereas EXPORT may evolve over time to support
	// other things (eg. fixing #33429).
	//
	// TODO(mjibson): Note that this is currently not suitable for
	// emitting arrays or tuples. See: #33429
	FmtExport FmtFlags = FmtBareStrings | fmtRawStrings
)

Composite/derived flag definitions follow.

func FmtExpr 

func FmtExpr(base FmtFlags, showTypes bool, symbolicVars bool, showTableAliases bool) FmtFlags

FmtExpr returns FmtFlags that indicate how the pretty-printer should format expressions.

func (FmtFlags) EncodeFlags 

func (f FmtFlags) EncodeFlags() lex.EncodeFlags

EncodeFlags returns the subset of the flags that are also lex encode flags.

func (FmtFlags) HasFlags 

func (f FmtFlags) HasFlags(subset FmtFlags) bool

HasFlags tests whether the given flags are all set.

func (*FmtFlags) SetFlags 

func (f *FmtFlags) SetFlags(subset FmtFlags)

SetFlags sets the given formatting flags.

type ForeignKeyConstraintTableDef 

type ForeignKeyConstraintTableDef struct {
	Name     Name
	Table    TableName
	FromCols NameList
	ToCols   NameList
	Actions  ReferenceActions
	Match    CompositeKeyMatchMethod
}

ForeignKeyConstraintTableDef represents a FOREIGN KEY constraint in the AST.

func (*ForeignKeyConstraintTableDef) Format 

func (node *ForeignKeyConstraintTableDef) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ForeignKeyConstraintTableDef) SetName 

func (node *ForeignKeyConstraintTableDef) SetName(name Name)

SetName implements the ConstraintTableDef interface.

type From 

type From struct {
	Tables TableExprs
	AsOf   AsOfClause
}

From represents a FROM clause.

func (*From) Format 

func (node *From) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type FullBackupClause 

type FullBackupClause struct {
	AlwaysFull bool
	Recurrence Expr
}

FullBackupClause describes the frequency of full backups.

type FuncExpr 

type FuncExpr struct {
	Func  ResolvableFunctionReference
	Type  funcType
	Exprs Exprs
	// Filter is used for filters on aggregates: SUM(k) FILTER (WHERE k > 0)
	Filter    Expr
	WindowDef *WindowDef

	// AggType is used to specify the type of aggregation.
	AggType AggType
	// OrderBy is used for aggregations which specify an order. This same field
	// is used for any type of aggregation.
	OrderBy OrderBy
	// contains filtered or unexported fields
}

FuncExpr represents a function call.

func NewTypedFuncExpr 

func NewTypedFuncExpr(
	ref ResolvableFunctionReference,
	aggQualifier funcType,
	exprs TypedExprs,
	filter TypedExpr,
	windowDef *WindowDef,
	typ *types.T,
	props *FunctionProperties,
	overload *Overload,
) *FuncExpr

NewTypedFuncExpr returns a FuncExpr that is already well-typed and resolved.

func (*FuncExpr) CanHandleNulls 

func (node *FuncExpr) CanHandleNulls() bool

CanHandleNulls returns whether or not the function can handle null arguments.

func (*FuncExpr) Eval 

func (expr *FuncExpr) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*FuncExpr) EvalArgsAndGetGenerator 

func (expr *FuncExpr) EvalArgsAndGetGenerator(ctx *EvalContext) (ValueGenerator, error)

EvalArgsAndGetGenerator evaluates the arguments and instanciates a ValueGenerator for use by set projections.

func (*FuncExpr) Format 

func (node *FuncExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*FuncExpr) IsDistSQLBlocklist 

func (node *FuncExpr) IsDistSQLBlocklist() bool

IsDistSQLBlocklist returns whether the function is not supported by DistSQL.

func (*FuncExpr) IsGeneratorApplication 

func (node *FuncExpr) IsGeneratorApplication() bool

IsGeneratorApplication returns true iff the function applied is a generator (SRF).

func (*FuncExpr) IsWindowFunctionApplication 

func (node *FuncExpr) IsWindowFunctionApplication() bool

IsWindowFunctionApplication returns true iff the function is being applied as a window function.

func (*FuncExpr) ResolvedOverload 

func (node *FuncExpr) ResolvedOverload() *Overload

ResolvedOverload returns the builtin definition; can only be called after Resolve (which happens during TypeCheck).

func (FuncExpr) ResolvedType 

func (ta FuncExpr) ResolvedType() *types.T

func (*FuncExpr) String 

func (node *FuncExpr) String() string

func (*FuncExpr) TypeCheck 

func (expr *FuncExpr) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*FuncExpr) Walk 

func (expr *FuncExpr) Walk(v Visitor) Expr

Walk implements the Expr interface.

type FunctionClass 

type FunctionClass int

FunctionClass specifies the class of the builtin function. 

const (
	// NormalClass is a standard builtin function.
	NormalClass FunctionClass = iota
	// AggregateClass is a builtin aggregate function.
	AggregateClass
	// WindowClass is a builtin window function.
	WindowClass
	// GeneratorClass is a builtin generator function.
	GeneratorClass
	// SQLClass is a builtin function that executes a SQL statement as a side
	// effect of the function call.
	//
	// For example, AddGeometryColumn is a SQLClass function that executes an
	// ALTER TABLE ... ADD COLUMN statement to add a geometry column to an
	// existing table. It returns metadata about the column added.
	//
	// All builtin functions of this class should include a definition for
	// Overload.SQLFn, which returns the SQL statement to be executed. They
	// should also include a definition for Overload.Fn, which is executed
	// like a NormalClass function and returns a Datum.
	SQLClass
)

type FunctionDefinition 

type FunctionDefinition struct {
	// Name is the short name of the function.
	Name string

	// Definition is the set of overloads for this function name.
	// We use []overloadImpl here although all the uses of this struct
	// could actually write a []Overload, because we want to share
	// the code with typeCheckOverloadedExprs().
	Definition []overloadImpl

	// FunctionProperties are the properties common to all overloads.
	FunctionProperties
}

FunctionDefinition implements a reference to the (possibly several) overloads for a built-in function.

func NewFunctionDefinition 

func NewFunctionDefinition(
	name string, props *FunctionProperties, def []Overload,
) *FunctionDefinition

NewFunctionDefinition allocates a function definition corresponding to the given built-in definition.

func (*FunctionDefinition) Format 

func (fd *FunctionDefinition) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*FunctionDefinition) String 

func (fd *FunctionDefinition) String() string

type FunctionProperties 

type FunctionProperties struct {
	// UnsupportedWithIssue, if non-zero indicates the built-in is not
	// really supported; the name is a placeholder. Value -1 just says
	// "not supported" without an issue to link; values > 0 provide an
	// issue number to link.
	UnsupportedWithIssue int

	// Undocumented, when set to true, indicates that the built-in function is
	// hidden from documentation. This is currently used to hide experimental
	// functionality as it is being developed.
	Undocumented bool

	// Private, when set to true, indicates the built-in function is not
	// available for use by user queries. This is currently used by some
	// aggregates due to issue #10495. Private functions are implicitly
	// considered undocumented.
	Private bool

	// NullableArgs is set to true when a function's definition can
	// handle NULL arguments. When set, the function will be given the
	// chance to see NULL arguments. When not, the function will
	// evaluate directly to NULL in the presence of any NULL arguments.
	//
	// NOTE: when set, a function should be prepared for any of its arguments to
	// be NULL and should act accordingly.
	NullableArgs bool

	// DistsqlBlocklist is set to true when a function depends on
	// members of the EvalContext that are not marshaled by DistSQL
	// (e.g. planner). Currently used for DistSQL to determine if
	// expressions can be evaluated on a different node without sending
	// over the EvalContext.
	//
	// TODO(andrei): Get rid of the planner from the EvalContext and then we can
	// get rid of this blocklist.
	DistsqlBlocklist bool

	// Class is the kind of built-in function (normal/aggregate/window/etc.)
	Class FunctionClass

	// Category is used to generate documentation strings.
	Category string

	// ReturnLabels can be used to override the return column name of a
	// function in a FROM clause.
	// This satisfies a Postgres quirk where some json functions have
	// different return labels when used in SELECT or FROM clause.
	ReturnLabels []string

	// AmbiguousReturnType is true if the builtin's return type can't be
	// determined without extra context. This is used for formatting builtins
	// with the FmtParsable directive.
	AmbiguousReturnType bool

	// HasSequenceArguments is true if the builtin function takes in a sequence
	// name (string) and can be used in a scalar expression.
	// TODO(richardjcai): When implicit casting is supported, these builtins
	// should take RegClass as the arg type for the sequence name instead of
	// string, we will add a dependency on all RegClass types used in a view.
	HasSequenceArguments bool
}

FunctionProperties defines the properties of the built-in functions that are common across all overloads.

func (*FunctionProperties) ShouldDocument 

func (fp *FunctionProperties) ShouldDocument() bool

ShouldDocument returns whether the built-in function should be included in external-facing documentation.

type FunctionReference 

type FunctionReference interface {
	fmt.Stringer
	NodeFormatter
	// contains filtered or unexported methods
}

FunctionReference is the common interface to UnresolvedName and QualifiedFunctionName.

type GeneratorFactory 

type GeneratorFactory func(ctx *EvalContext, args Datums) (ValueGenerator, error)

GeneratorFactory is the type of constructor functions for ValueGenerator objects.

type Grant 

type Grant struct {
	Privileges privilege.List
	Targets    TargetList
	Grantees   NameList
}

Grant represents a GRANT statement.

func (*Grant) Format 

func (node *Grant) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Grant) StatementTag 

func (*Grant) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Grant) StatementType 

func (*Grant) StatementType() StatementType

StatementType implements the Statement interface.

func (*Grant) String 

func (n *Grant) String() string

type GrantRole 

type GrantRole struct {
	Roles       NameList
	Members     NameList
	AdminOption bool
}

GrantRole represents a GRANT <role> statement.

func (*GrantRole) Format 

func (node *GrantRole) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*GrantRole) StatementTag 

func (*GrantRole) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*GrantRole) StatementType 

func (*GrantRole) StatementType() StatementType

StatementType implements the Statement interface.

func (*GrantRole) String 

func (n *GrantRole) String() string

type GroupBy 

type GroupBy []Expr

GroupBy represents a GROUP BY clause.

func (*GroupBy) Format 

func (node *GroupBy) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type HiddenFromShowQueries 

type HiddenFromShowQueries interface {
	// contains filtered or unexported methods
}

HiddenFromShowQueries is a pseudo-interface to be implemented by statements that should not show up in SHOW QUERIES (and are hence not cancellable using CANCEL QUERIES either). Usually implemented by statements that spawn jobs.

type HomogeneousType 

type HomogeneousType struct{}

HomogeneousType is a TypeList implementation that accepts any arguments, as long as all are the same type or NULL. The homogeneous constraint is enforced in typeCheckOverloadedExprs.

func (HomogeneousType) GetAt 

func (HomogeneousType) GetAt(i int) *types.T

GetAt is part of the TypeList interface.

func (HomogeneousType) Length 

func (HomogeneousType) Length() int

Length is part of the TypeList interface.

func (HomogeneousType) Match 

func (HomogeneousType) Match(types []*types.T) bool

Match is part of the TypeList interface.

func (HomogeneousType) MatchAt 

func (HomogeneousType) MatchAt(typ *types.T, i int) bool

MatchAt is part of the TypeList interface.

func (HomogeneousType) MatchLen 

func (HomogeneousType) MatchLen(l int) bool

MatchLen is part of the TypeList interface.

func (HomogeneousType) String 

func (HomogeneousType) String() string

func (HomogeneousType) Types 

func (HomogeneousType) Types() []*types.T

Types is part of the TypeList interface.

type ID 

type ID uint32

ID is a custom type for {Database,Table}Descriptor IDs.

type IDTypeReference 

type IDTypeReference struct {
	ID uint32
}

IDTypeReference is a reference to a type directly by its stable ID.

func (*IDTypeReference) SQLString 

func (node *IDTypeReference) SQLString() string

SQLString implements the ResolvableTypeReference interface.

type IfErrExpr 

type IfErrExpr struct {
	Cond    Expr
	Else    Expr
	ErrCode Expr
	// contains filtered or unexported fields
}

IfErrExpr represents an IFERROR expression.

func NewTypedIfErrExpr 

func NewTypedIfErrExpr(cond, orElse, errCode TypedExpr) *IfErrExpr

NewTypedIfErrExpr returns a new IfErrExpr that is verified to be well-typed.

func (*IfErrExpr) Eval 

func (expr *IfErrExpr) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*IfErrExpr) Format 

func (node *IfErrExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (IfErrExpr) ResolvedType 

func (ta IfErrExpr) ResolvedType() *types.T

func (*IfErrExpr) String 

func (node *IfErrExpr) String() string

func (*IfErrExpr) TypeCheck 

func (expr *IfErrExpr) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*IfErrExpr) Walk 

func (expr *IfErrExpr) Walk(v Visitor) Expr

Walk implements the Expr interface.

type IfExpr 

type IfExpr struct {
	Cond Expr
	True Expr
	Else Expr
	// contains filtered or unexported fields
}

IfExpr represents an IF expression.

func (*IfExpr) Eval 

func (expr *IfExpr) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*IfExpr) Format 

func (node *IfExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (IfExpr) ResolvedType 

func (ta IfExpr) ResolvedType() *types.T

func (*IfExpr) String 

func (node *IfExpr) String() string

func (*IfExpr) TypeCheck 

func (expr *IfExpr) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*IfExpr) TypedCondExpr 

func (node *IfExpr) TypedCondExpr() TypedExpr

TypedCondExpr returns the IfExpr's Cond expression as a TypedExpr.

func (*IfExpr) TypedElseExpr 

func (node *IfExpr) TypedElseExpr() TypedExpr

TypedElseExpr returns the IfExpr's Else expression as a TypedExpr.

func (*IfExpr) TypedTrueExpr 

func (node *IfExpr) TypedTrueExpr() TypedExpr

TypedTrueExpr returns the IfExpr's True expression as a TypedExpr.

func (*IfExpr) Walk 

func (expr *IfExpr) Walk(v Visitor) Expr

Walk implements the Expr interface.

type Import 

type Import struct {
	Table      *TableName
	Into       bool
	IntoCols   NameList
	CreateFile Expr
	CreateDefs TableDefs
	FileFormat string
	Files      Exprs
	Bundle     bool
	Options    KVOptions
}

Import represents a IMPORT statement.

func (*Import) Format 

func (node *Import) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Import) StatementTag 

func (*Import) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Import) StatementType 

func (n *Import) StatementType() StatementType

StatementType implements the Statement interface.

func (*Import) String 

func (n *Import) String() string

type IndexElem 

type IndexElem struct {
	Column     Name
	Direction  Direction
	NullsOrder NullsOrder
}

IndexElem represents a column with a direction in a CREATE INDEX statement.

func (*IndexElem) Format 

func (node *IndexElem) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type IndexElemList 

type IndexElemList []IndexElem

IndexElemList is list of IndexElem.

func (*IndexElemList) Format 

func (l *IndexElemList) Format(ctx *FmtCtx)

Format pretty-prints the contained names separated by commas. Format implements the NodeFormatter interface.

type IndexFlags 

type IndexFlags struct {
	Index   UnrestrictedName
	IndexID IndexID
	// Direction of the scan, if provided. Can only be set if
	// one of Index or IndexID is set.
	Direction Direction
	// NoIndexJoin cannot be specified together with an index.
	NoIndexJoin bool
	// IgnoreForeignKeys disables optimizations based on outbound foreign key
	// references from this table. This is useful in particular for scrub queries
	// used to verify the consistency of foreign key relations.
	IgnoreForeignKeys bool
}

IndexFlags represents "@<index_name|index_id>" or "@{param[,param]}" where param is one of:

  • FORCE_INDEX=<index_name|index_id>
  • ASC / DESC
  • NO_INDEX_JOIN
  • IGNORE_FOREIGN_KEYS

It is used optionally after a table name in SELECT statements.

func (*IndexFlags) Check 

func (ih *IndexFlags) Check() error

Check verifies if the flags are valid:

  • ascending/descending is not specified without an index;
  • no_index_join isn't specified with an index.

func (*IndexFlags) CombineWith 

func (ih *IndexFlags) CombineWith(other *IndexFlags) error

CombineWith combines two IndexFlags structures, returning an error if they conflict with one another.

func (*IndexFlags) ForceIndex 

func (ih *IndexFlags) ForceIndex() bool

ForceIndex returns true if a forced index was specified, either using a name or an IndexID.

func (*IndexFlags) Format 

func (ih *IndexFlags) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type IndexID 

type IndexID uint32

IndexID is a custom type for IndexDescriptor IDs.

type IndexTableDef 

type IndexTableDef struct {
	Name        Name
	Columns     IndexElemList
	Sharded     *ShardedIndexDef
	Storing     NameList
	Interleave  *InterleaveDef
	Inverted    bool
	PartitionBy *PartitionBy
	Predicate   Expr
}

IndexTableDef represents an index definition within a CREATE TABLE statement.

func (*IndexTableDef) Format 

func (node *IndexTableDef) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type IndexedRow 

type IndexedRow interface {
	GetIdx() int                                    // returns index of the row
	GetDatum(idx int) (Datum, error)                // returns a datum at the given index
	GetDatums(startIdx, endIdx int) (Datums, error) // returns datums at indices [startIdx, endIdx)
}

IndexedRow is a row with a corresponding index.

type IndexedRows 

type IndexedRows interface {
	Len() int                                                // returns number of rows
	GetRow(ctx context.Context, idx int) (IndexedRow, error) // returns a row at the given index or an error
}

IndexedRows are rows with the corresponding indices.

type IndexedVar 

type IndexedVar struct {
	Idx  int
	Used bool
	// contains filtered or unexported fields
}

IndexedVar is a VariableExpr that can be used as a leaf in expressions; it represents a dynamic value. It defers calls to TypeCheck, Eval, String to an IndexedVarContainer.

func NewOrdinalReference 

func NewOrdinalReference(r int) *IndexedVar

NewOrdinalReference is a helper routine to create a standalone IndexedVar with the given index value. This needs to undergo BindIfUnbound() below before it can be fully used.

func NewTypedOrdinalReference 

func NewTypedOrdinalReference(r int, typ *types.T) *IndexedVar

NewTypedOrdinalReference returns a new IndexedVar with the given index value that is verified to be well-typed.

func (*IndexedVar) Eval 

func (v *IndexedVar) Eval(ctx *EvalContext) (Datum, error)

Eval is part of the TypedExpr interface.

func (*IndexedVar) Format 

func (v *IndexedVar) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*IndexedVar) ResolvedType 

func (v *IndexedVar) ResolvedType() *types.T

ResolvedType is part of the TypedExpr interface.

func (*IndexedVar) String 

func (node *IndexedVar) String() string

func (*IndexedVar) TypeCheck 

func (v *IndexedVar) TypeCheck(
	_ context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck is part of the Expr interface.

func (*IndexedVar) Variable 

func (*IndexedVar) Variable()

Variable is a dummy function part of the VariableExpr interface.

func (*IndexedVar) Walk 

func (v *IndexedVar) Walk(_ Visitor) Expr

Walk is part of the Expr interface.

type IndexedVarContainer 

type IndexedVarContainer interface {
	IndexedVarEval(idx int, ctx *EvalContext) (Datum, error)
	IndexedVarResolvedType(idx int) *types.T
	// IndexedVarNodeFormatter returns a NodeFormatter; if an object that
	// wishes to implement this interface has lost the textual name that an
	// IndexedVar originates from, this function can return nil (and the
	// ordinal syntax "@1, @2, .." will be used).
	IndexedVarNodeFormatter(idx int) NodeFormatter
}

IndexedVarContainer provides the implementation of TypeCheck, Eval, and String for IndexedVars.

type IndexedVarHelper 

type IndexedVarHelper struct {
	// contains filtered or unexported fields
}

IndexedVarHelper wraps an IndexedVarContainer (an interface) and creates IndexedVars bound to that container.

It also keeps track of which indexes from the container are used by expressions.

func MakeIndexedVarHelper 

func MakeIndexedVarHelper(container IndexedVarContainer, numVars int) IndexedVarHelper

MakeIndexedVarHelper initializes an IndexedVarHelper structure.

func MakeTypesOnlyIndexedVarHelper 

func MakeTypesOnlyIndexedVarHelper(types []*types.T) IndexedVarHelper

MakeTypesOnlyIndexedVarHelper creates an IndexedVarHelper which provides the given types for indexed vars. It does not support evaluation, unless Rebind is used with another container which supports evaluation.

func (*IndexedVarHelper) AppendSlot 

func (h *IndexedVarHelper) AppendSlot() int

AppendSlot expands the capacity of this IndexedVarHelper by one and returns the index of the new slot.

func (*IndexedVarHelper) BindIfUnbound 

func (h *IndexedVarHelper) BindIfUnbound(ivar *IndexedVar) (*IndexedVar, error)

BindIfUnbound ensures the IndexedVar is attached to this helper's container. - for freshly created IndexedVars (with a nil container) this will bind in-place. - for already bound IndexedVar, bound to this container, this will return the same ivar unchanged. - for ordinal references (with an explicit unboundContainer) this will return a new var. - for already bound IndexedVars, bound to another container, this will error out.

func (*IndexedVarHelper) Container 

func (h *IndexedVarHelper) Container() IndexedVarContainer

Container returns the container associated with the helper.

func (*IndexedVarHelper) GetIndexedVars 

func (h *IndexedVarHelper) GetIndexedVars() []IndexedVar

GetIndexedVars returns the indexed var array of this helper. IndexedVars to the caller; unused vars are guaranteed to have a false Used field.

func (*IndexedVarHelper) IndexedVar 

func (h *IndexedVarHelper) IndexedVar(idx int) *IndexedVar

IndexedVar returns an IndexedVar for the given index. The index must be valid.

func (*IndexedVarHelper) IndexedVarUsed 

func (h *IndexedVarHelper) IndexedVarUsed(idx int) bool

IndexedVarUsed returns true if IndexedVar() was called for the given index. The index must be valid.

func (*IndexedVarHelper) IndexedVarWithType 

func (h *IndexedVarHelper) IndexedVarWithType(idx int, typ *types.T) *IndexedVar

IndexedVarWithType returns an IndexedVar for the given index, with the given type. The index must be valid. This should be used in the case where an indexed var is being added before its container has a corresponding entry for it.

func (*IndexedVarHelper) NumVars 

func (h *IndexedVarHelper) NumVars() int

NumVars returns the number of variables the IndexedVarHelper was initialized for.

func (*IndexedVarHelper) Rebind 

func (h *IndexedVarHelper) Rebind(expr TypedExpr) TypedExpr

Rebind collects all the IndexedVars in the given expression and re-binds them to this helper.

func (*IndexedVarHelper) VisitPost 

func (*IndexedVarHelper) VisitPost(expr Expr) Expr

VisitPost implements the Visitor interface.

func (*IndexedVarHelper) VisitPre 

func (h *IndexedVarHelper) VisitPre(expr Expr) (recurse bool, newExpr Expr)

VisitPre implements the Visitor interface.

type IndirectionExpr 

type IndirectionExpr struct {
	Expr        Expr
	Indirection ArraySubscripts
	// contains filtered or unexported fields
}

IndirectionExpr represents a subscript expression.

func NewTypedIndirectionExpr 

func NewTypedIndirectionExpr(expr, index TypedExpr, typ *types.T) *IndirectionExpr

NewTypedIndirectionExpr returns a new IndirectionExpr that is verified to be well-typed.

func (*IndirectionExpr) Eval 

func (expr *IndirectionExpr) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*IndirectionExpr) Format 

func (node *IndirectionExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (IndirectionExpr) ResolvedType 

func (ta IndirectionExpr) ResolvedType() *types.T

func (*IndirectionExpr) String 

func (node *IndirectionExpr) String() string

func (*IndirectionExpr) TypeCheck 

func (expr *IndirectionExpr) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*IndirectionExpr) Walk 

func (expr *IndirectionExpr) Walk(v Visitor) Expr

Walk implements the Expr interface.

type Insert 

type Insert struct {
	With       *With
	Table      TableExpr
	Columns    NameList
	Rows       *Select
	OnConflict *OnConflict
	Returning  ReturningClause
}

Insert represents an INSERT statement.

func (*Insert) DefaultValues 

func (node *Insert) DefaultValues() bool

DefaultValues returns true iff only default values are being inserted.

func (*Insert) Format 

func (node *Insert) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Insert) StatementTag 

func (*Insert) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Insert) StatementType 

func (n *Insert) StatementType() StatementType

StatementType implements the Statement interface.

func (*Insert) String 

func (n *Insert) String() string

type InterleaveDef 

type InterleaveDef struct {
	Parent       TableName
	Fields       NameList
	DropBehavior DropBehavior
}

InterleaveDef represents an interleave definition within a CREATE TABLE or CREATE INDEX statement.

func (*InterleaveDef) Format 

func (node *InterleaveDef) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type InternalExecutor 

type InternalExecutor interface {
	// Query is part of the sqlutil.InternalExecutor interface.
	Query(
		ctx context.Context, opName string,
		stmt string, qargs ...interface{},
	) ([]Datums, error)

	// QueryRow is part of the sqlutil.InternalExecutor interface.
	QueryRow(
		ctx context.Context, opName string, stmt string, qargs ...interface{},
	) (Datums, error)
}

InternalExecutor is a subset of sqlutil.InternalExecutor (which, in turn, is implemented by sql.InternalExecutor) used by this sem/tree package which can't even import sqlutil.

Note that the functions offered here should be avoided when possible. They execute the query as root if an user hadn't been previously set on the executor through SetSessionData(). These functions are deprecated in sql.InternalExecutor in favor of a safer interface. Unfortunately, those safer functions cannot be exposed through this interface because they depend on sqlbase, and this package cannot import sqlbase. When possible, downcast this to sqlutil.InternalExecutor or sql.InternalExecutor, and use the alternatives.

type IsNotNullExpr 

type IsNotNullExpr struct {
	Expr Expr
	// contains filtered or unexported fields
}

IsNotNullExpr represents an IS NOT NULL expression. This is equivalent to IS DISTINCT FROM NULL, except when the input is a tuple.

func NewTypedIsNotNullExpr 

func NewTypedIsNotNullExpr(expr TypedExpr) *IsNotNullExpr

NewTypedIsNotNullExpr returns a new IsNotNullExpr that is verified to be well-typed.

func (*IsNotNullExpr) Eval 

func (expr *IsNotNullExpr) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*IsNotNullExpr) Format 

func (node *IsNotNullExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (IsNotNullExpr) ResolvedType 

func (ta IsNotNullExpr) ResolvedType() *types.T

func (*IsNotNullExpr) String 

func (node *IsNotNullExpr) String() string

func (*IsNotNullExpr) TypeCheck 

func (expr *IsNotNullExpr) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*IsNotNullExpr) TypedInnerExpr 

func (node *IsNotNullExpr) TypedInnerExpr() TypedExpr

TypedInnerExpr returns the IsNotNullExpr's inner expression as a TypedExpr.

func (*IsNotNullExpr) Walk 

func (expr *IsNotNullExpr) Walk(v Visitor) Expr

Walk implements the Expr interface.

type IsNullExpr 

type IsNullExpr struct {
	Expr Expr
	// contains filtered or unexported fields
}

IsNullExpr represents an IS NULL expression. This is equivalent to IS NOT DISTINCT FROM NULL, except when the input is a tuple.

func NewTypedIsNullExpr 

func NewTypedIsNullExpr(expr TypedExpr) *IsNullExpr

NewTypedIsNullExpr returns a new IsNullExpr that is verified to be well-typed.

func (*IsNullExpr) Eval 

func (expr *IsNullExpr) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*IsNullExpr) Format 

func (node *IsNullExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (IsNullExpr) ResolvedType 

func (ta IsNullExpr) ResolvedType() *types.T

func (*IsNullExpr) String 

func (node *IsNullExpr) String() string

func (*IsNullExpr) TypeCheck 

func (expr *IsNullExpr) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*IsNullExpr) TypedInnerExpr 

func (node *IsNullExpr) TypedInnerExpr() TypedExpr

TypedInnerExpr returns the IsNullExpr's inner expression as a TypedExpr.

func (*IsNullExpr) Walk 

func (expr *IsNullExpr) Walk(v Visitor) Expr

Walk implements the Expr interface.

type IsOfTypeExpr 

type IsOfTypeExpr struct {
	Not   bool
	Expr  Expr
	Types []ResolvableTypeReference
	// contains filtered or unexported fields
}

IsOfTypeExpr represents an IS {,NOT} OF (type_list) expression.

func (*IsOfTypeExpr) Eval 

func (expr *IsOfTypeExpr) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*IsOfTypeExpr) Format 

func (node *IsOfTypeExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (IsOfTypeExpr) ResolvedType 

func (ta IsOfTypeExpr) ResolvedType() *types.T

func (*IsOfTypeExpr) ResolvedTypes 

func (node *IsOfTypeExpr) ResolvedTypes() []*types.T

ResolvedTypes returns a slice of resolved types corresponding to the Types slice of unresolved types. It may only be accessed after typechecking.

func (*IsOfTypeExpr) String 

func (node *IsOfTypeExpr) String() string

func (*IsOfTypeExpr) TypeCheck 

func (expr *IsOfTypeExpr) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*IsOfTypeExpr) Walk 

func (expr *IsOfTypeExpr) Walk(v Visitor) Expr

Walk implements the Expr interface.

type IsolationLevel 

type IsolationLevel int

IsolationLevel holds the isolation level for a transaction. 

const (
	UnspecifiedIsolation IsolationLevel = iota
	SerializableIsolation
)

IsolationLevel values

func (IsolationLevel) String 

func (i IsolationLevel) String() string

type JobCommand 

type JobCommand int

JobCommand determines which type of action to effect on the selected job(s). 

const (
	PauseJob JobCommand = iota
	CancelJob
	ResumeJob
)

JobCommand values

type JoinCond 

type JoinCond interface {
	NodeFormatter
	// contains filtered or unexported methods
}

JoinCond represents a join condition.

type JoinTableExpr 

type JoinTableExpr struct {
	JoinType string
	Left     TableExpr
	Right    TableExpr
	Cond     JoinCond
	Hint     string
}

JoinTableExpr represents a TableExpr that's a JOIN operation.

func (*JoinTableExpr) Format 

func (node *JoinTableExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*JoinTableExpr) String 

func (node *JoinTableExpr) String() string

type KVOption 

type KVOption struct {
	Key   Name
	Value Expr
}

KVOption is a key-value option.

type KVOptions 

type KVOptions []KVOption

KVOptions is a list of KVOptions.

func (*KVOptions) Format 

func (o *KVOptions) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (KVOptions) ToRoleOptions 

func (o KVOptions) ToRoleOptions(
	typeAsStringOrNull func(e Expr, op string) (func() (bool, string, error), error), op string,
) (roleoption.List, error)

ToRoleOptions converts KVOptions to a roleoption.List using typeAsString to convert exprs to strings.

type LikeTableDef 

type LikeTableDef struct {
	Name    TableName
	Options []LikeTableOption
}

LikeTableDef represents a LIKE table declaration on a CREATE TABLE statement.

func (*LikeTableDef) Format 

func (def *LikeTableDef) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type LikeTableOpt 

type LikeTableOpt int

LikeTableOpt represents one of the types of things that can be included or excluded in a LIKE table declaration. It's a bitmap, where each of the Opt values is a single enabled bit in the map. 

const (
	LikeTableOptConstraints LikeTableOpt = 1 << iota
	LikeTableOptDefaults
	LikeTableOptGenerated
	LikeTableOptIndexes
)

The values for LikeTableOpt.

func (LikeTableOpt) Has 

func (o LikeTableOpt) Has(other LikeTableOpt) bool

Has returns true if the receiver has the other options bits set.

func (LikeTableOpt) String 

func (o LikeTableOpt) String() string

type LikeTableOption 

type LikeTableOption struct {
	Excluded bool
	Opt      LikeTableOpt
}

LikeTableOption represents an individual INCLUDING / EXCLUDING statement on a LIKE table declaration.

func (LikeTableOption) Format 

func (l LikeTableOption) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type Limit 

type Limit struct {
	Offset, Count Expr
	LimitAll      bool
}

Limit represents a LIMIT clause.

func (*Limit) Format 

func (node *Limit) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type ListPartition 

type ListPartition struct {
	Name         UnrestrictedName
	Exprs        Exprs
	Subpartition *PartitionBy
}

ListPartition represents a PARTITION definition within a PARTITION BY LIST.

func (*ListPartition) Format 

func (node *ListPartition) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type LockingClause 

type LockingClause []*LockingItem

LockingClause represents a locking clause, like FOR UPDATE.

func (*LockingClause) Format 

func (node *LockingClause) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type LockingItem 

type LockingItem struct {
	Strength   LockingStrength
	Targets    TableNames
	WaitPolicy LockingWaitPolicy
}

LockingItem represents a single locking item in a locking clause.

NOTE: if this struct changes, HashLockingItem and IsLockingItemEqual in opt/memo/interner.go will need to be updated accordingly.

func (*LockingItem) Format 

func (f *LockingItem) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type LockingStrength 

type LockingStrength byte

LockingStrength represents the possible row-level lock modes for a SELECT statement. 

const (
	// ForNone represents the default - no for statement at all.
	// LockingItem AST nodes are never created with this strength.
	ForNone LockingStrength = iota
	// ForKeyShare represents FOR KEY SHARE.
	ForKeyShare
	// ForShare represents FOR SHARE.
	ForShare
	// ForNoKeyUpdate represents FOR NO KEY UPDATE.
	ForNoKeyUpdate
	// ForUpdate represents FOR UPDATE.
	ForUpdate
)

The ordering of the variants is important, because the highest numerical value takes precedence when row-level locking is specified multiple ways.

func (LockingStrength) Format 

func (s LockingStrength) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (LockingStrength) Max 

func (s LockingStrength) Max(s2 LockingStrength) LockingStrength

Max returns the maximum of the two locking strengths.

func (LockingStrength) String 

func (s LockingStrength) String() string

type LockingWaitPolicy 

type LockingWaitPolicy byte

LockingWaitPolicy represents the possible policies for dealing with rows being locked by FOR UPDATE/SHARE clauses (i.e., it represents the NOWAIT and SKIP LOCKED options). 

const (
	// LockWaitBlock represents the default - wait for the lock to become
	// available.
	LockWaitBlock LockingWaitPolicy = iota
	// LockWaitSkip represents SKIP LOCKED - skip rows that can't be locked.
	LockWaitSkip
	// LockWaitError represents NOWAIT - raise an error if a row cannot be
	// locked.
	LockWaitError
)

The ordering of the variants is important, because the highest numerical value takes precedence when row-level locking is specified multiple ways.

func (LockingWaitPolicy) Format 

func (p LockingWaitPolicy) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (LockingWaitPolicy) Max 

func (p LockingWaitPolicy) Max(p2 LockingWaitPolicy) LockingWaitPolicy

Max returns the maximum of the two locking wait policies.

func (LockingWaitPolicy) String 

func (p LockingWaitPolicy) String() string

type MaterializeClause 

type MaterializeClause struct {
	// Set controls whether to use the Materialize bool instead of the default.
	Set bool

	// Materialize overrides the default materialization behavior.
	Materialize bool
}

MaterializeClause represents a materialize clause inside of a WITH clause.

type MultipleResultsError 

type MultipleResultsError struct {
	SQL string // the query that produced this error
}

MultipleResultsError is returned by QueryRow when more than one result is encountered.

func (*MultipleResultsError) Error 

func (e *MultipleResultsError) Error() string

type Name 

type Name string

A Name is an SQL identifier.

In general, a Name is the result of parsing a name nonterminal, which is used in the grammar where reserved keywords cannot be distinguished from identifiers. A Name that matches a reserved keyword must thus be quoted when formatted. (Names also need quoting for a variety of other reasons; see isBareIdentifier.)

For historical reasons, some Names are instead the result of parsing `unrestricted_name` nonterminals. See UnrestrictedName for details.

func (*Name) Format 

func (n *Name) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (Name) Normalize 

func (n Name) Normalize() string

Normalize normalizes to lowercase and Unicode Normalization Form C (NFC).

func (*Name) String 

func (node *Name) String() string

type NameList 

type NameList []Name

A NameList is a list of identifiers.

func (*NameList) Format 

func (l *NameList) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*NameList) String 

func (list *NameList) String() string

func (NameList) ToStrings 

func (l NameList) ToStrings() []string

ToStrings converts the name list to an array of regular strings.

type NameParts 

type NameParts = [4]string

NameParts is the array of strings that composes the path in an UnresolvedName.

type NameResolutionResult 

type NameResolutionResult interface {
	// NameResolutionResult is the interface anchor.
	NameResolutionResult()
}

NameResolutionResult is an opaque reference returned by LookupObject().

type NamedColumnQualification 

type NamedColumnQualification struct {
	Name          Name
	Qualification ColumnQualification
}

NamedColumnQualification wraps a NamedColumnQualification with a name.

type NaturalJoinCond 

type NaturalJoinCond struct{}

NaturalJoinCond represents a NATURAL join condition

func (NaturalJoinCond) Format 

func (NaturalJoinCond) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type NoReturningClause 

type NoReturningClause struct{}

NoReturningClause represents the absence of a RETURNING clause.

func (*NoReturningClause) Format 

func (*NoReturningClause) Format(_ *FmtCtx)

Format implements the NodeFormatter interface.

type NodeFormatter 

type NodeFormatter interface {
	// Format performs pretty-printing towards a bytes buffer. The flags member
	// of ctx influences the results. Most callers should use FormatNode instead.
	Format(ctx *FmtCtx)
}

NodeFormatter is implemented by nodes that can be pretty-printed.

type NormalizeVisitor 

type NormalizeVisitor struct {
	// contains filtered or unexported fields
}

NormalizeVisitor supports the execution of NormalizeExpr.

func MakeNormalizeVisitor 

func MakeNormalizeVisitor(ctx *EvalContext) NormalizeVisitor

MakeNormalizeVisitor creates a NormalizeVisitor instance.

func (*NormalizeVisitor) Err 

func (v *NormalizeVisitor) Err() error

Err retrieves the error field in the NormalizeVisitor.

func (*NormalizeVisitor) VisitPost 

func (v *NormalizeVisitor) VisitPost(expr Expr) Expr

VisitPost implements the Visitor interface.

func (*NormalizeVisitor) VisitPre 

func (v *NormalizeVisitor) VisitPre(expr Expr) (recurse bool, newExpr Expr)

VisitPre implements the Visitor interface.

type NotExpr 

type NotExpr struct {
	Expr Expr
	// contains filtered or unexported fields
}

NotExpr represents a NOT expression.

func NewTypedNotExpr 

func NewTypedNotExpr(expr TypedExpr) *NotExpr

NewTypedNotExpr returns a new NotExpr that is verified to be well-typed.

func (*NotExpr) Eval 

func (expr *NotExpr) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*NotExpr) Format 

func (node *NotExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (NotExpr) ResolvedType 

func (ta NotExpr) ResolvedType() *types.T

func (*NotExpr) String 

func (node *NotExpr) String() string

func (*NotExpr) TypeCheck 

func (expr *NotExpr) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*NotExpr) TypedInnerExpr 

func (node *NotExpr) TypedInnerExpr() TypedExpr

TypedInnerExpr returns the NotExpr's inner expression as a TypedExpr.

func (*NotExpr) Walk 

func (expr *NotExpr) Walk(v Visitor) Expr

Walk implements the Expr interface.

type NotNullConstraint 

type NotNullConstraint struct{}

NotNullConstraint represents NOT NULL on a column.

type NullConstraint 

type NullConstraint struct{}

NullConstraint represents NULL on a column.

type NullIfExpr 

type NullIfExpr struct {
	Expr1 Expr
	Expr2 Expr
	// contains filtered or unexported fields
}

NullIfExpr represents a NULLIF expression.

func (*NullIfExpr) Eval 

func (expr *NullIfExpr) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*NullIfExpr) Format 

func (node *NullIfExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (NullIfExpr) ResolvedType 

func (ta NullIfExpr) ResolvedType() *types.T

func (*NullIfExpr) String 

func (node *NullIfExpr) String() string

func (*NullIfExpr) TypeCheck 

func (expr *NullIfExpr) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*NullIfExpr) Walk 

func (expr *NullIfExpr) Walk(v Visitor) Expr

Walk implements the Expr interface.

type Nullability 

type Nullability int

Nullability represents either NULL, NOT NULL or an unspecified value (silent NULL). 

const (
	NotNull Nullability = iota
	Null
	SilentNull
)

The values for NullType.

type NullsOrder 

type NullsOrder int8

NullsOrder for specifying ordering of NULLs. 

const (
	DefaultNullsOrder NullsOrder = iota
	NullsFirst
	NullsLast
)

Null order values.

func (NullsOrder) String 

func (n NullsOrder) String() string

type NumResolutionResults 

type NumResolutionResults int

NumResolutionResults represents the number of results in the lookup of data sources matching a given prefix. 

const (
	// NoResults for when there is no result.
	NoResults NumResolutionResults = iota
	// ExactlyOne indicates just one source matching the requested name.
	ExactlyOne
	// MoreThanOne signals an ambiguous match.
	MoreThanOne
)

type NumVal 

type NumVal struct {
	// contains filtered or unexported fields
}

NumVal represents a constant numeric value.

func NewNumVal 

func NewNumVal(value constant.Value, origString string, negative bool) *NumVal

NewNumVal constructs a new NumVal instance. This is used during parsing and in tests.

func (*NumVal) AsConstantInt 

func (expr *NumVal) AsConstantInt() (constant.Value, bool)

AsConstantInt returns the value as an constant.Int if possible, along with a flag indicating whether the conversion was possible. The result contains the proper sign as per expr.negative.

func (*NumVal) AsConstantValue 

func (expr *NumVal) AsConstantValue() constant.Value

AsConstantValue returns the value as a constant numerical value, with the proper sign as given by expr.negative.

func (*NumVal) AsInt32 

func (expr *NumVal) AsInt32() (int32, error)

AsInt32 returns the value as 32-bit integer if possible, or returns an error if not possible. The method will set expr.resInt to the value of this int32 if it is successful, avoiding the need to call the method again.

func (*NumVal) AsInt64 

func (expr *NumVal) AsInt64() (int64, error)

AsInt64 returns the value as a 64-bit integer if possible, or returns an error if not possible. The method will set expr.resInt to the value of this int64 if it is successful, avoiding the need to call the method again.

func (*NumVal) AvailableTypes 

func (expr *NumVal) AvailableTypes() []*types.T

AvailableTypes implements the Constant interface.

func (*NumVal) DesirableTypes 

func (expr *NumVal) DesirableTypes() []*types.T

DesirableTypes implements the Constant interface.

func (*NumVal) ExactString 

func (expr *NumVal) ExactString() string

ExactString implements the constant.Value interface.

func (*NumVal) Format 

func (expr *NumVal) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*NumVal) Kind 

func (expr *NumVal) Kind() constant.Kind

Kind implements the constant.Value interface.

func (*NumVal) Negate 

func (expr *NumVal) Negate()

Negate sets the negative field to the opposite of its current value. The parser calls this to simplify unary negation expressions.

func (*NumVal) OrigString 

func (expr *NumVal) OrigString() string

OrigString returns the origString field.

func (*NumVal) ResolveAsType 

func (expr *NumVal) ResolveAsType(
	ctx context.Context, semaCtx *SemaContext, typ *types.T,
) (TypedExpr, error)

ResolveAsType implements the Constant interface.

func (*NumVal) SetNegative 

func (expr *NumVal) SetNegative()

SetNegative sets the negative field to true. The parser calls this when it identifies a negative constant.

func (*NumVal) ShouldBeInt64 

func (expr *NumVal) ShouldBeInt64() bool

ShouldBeInt64 checks if the value naturally is an int64: 

1   = yes
1.0 = no
1.1 = no
123...overflow...456 = no

func (*NumVal) String 

func (node *NumVal) String() string

func (*NumVal) TypeCheck 

func (expr *NumVal) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*NumVal) Walk 

func (expr *NumVal) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type ObjectLookupFlags 

type ObjectLookupFlags struct {
	CommonLookupFlags
	// return a MutableTableDescriptor
	RequireMutable         bool
	IncludeOffline         bool
	AllowWithoutPrimaryKey bool
	// Control what type of object is being requested.
	DesiredObjectKind DesiredObjectKind
	// Control what kind of table object is being requested. This field is
	// only respected when DesiredObjectKind is TableObject.
	DesiredTableDescKind RequiredTableKind
}

ObjectLookupFlags is the flag struct suitable for GetObjectDesc().

func ObjectLookupFlagsWithRequired 

func ObjectLookupFlagsWithRequired() ObjectLookupFlags

ObjectLookupFlagsWithRequired returns a default ObjectLookupFlags object with just the Required flag true. This is a common configuration of the flags.

func ObjectLookupFlagsWithRequiredTableKind 

func ObjectLookupFlagsWithRequiredTableKind(kind RequiredTableKind) ObjectLookupFlags

ObjectLookupFlagsWithRequiredTableKind returns an ObjectLookupFlags with Required set to true, and the DesiredTableDescKind set to the input kind.

type ObjectName 

type ObjectName interface {
	NodeFormatter
	Object() string
	Schema() string
	Catalog() string
	FQString() string
	// contains filtered or unexported methods
}

ObjectName is a common interface for qualified object names.

func NewQualifiedObjectName 

func NewQualifiedObjectName(catalog, schema, object string, kind DesiredObjectKind) ObjectName

NewQualifiedObjectName returns an ObjectName of the corresponding kind. It is used mainly for constructing appropriate error messages depending on what kind of object was requested.

type ObjectNameExistingResolver 

type ObjectNameExistingResolver interface {
	LookupObject(ctx context.Context, flags ObjectLookupFlags, dbName, scName, obName string) (
		found bool, objMeta NameResolutionResult, err error,
	)
}

ObjectNameExistingResolver is the helper interface to resolve table names when the object is expected to exist already. The boolean passed is used to specify if a MutableTableDescriptor is to be returned in the result.

type ObjectNamePrefix 

type ObjectNamePrefix struct {
	CatalogName Name
	SchemaName  Name

	// ExplicitCatalog is true iff the catalog was explicitly specified
	// or it needs to be rendered during pretty-printing.
	ExplicitCatalog bool
	// ExplicitSchema is true iff the schema was explicitly specified
	// or it needs to be rendered during pretty-printing.
	ExplicitSchema bool
}

ObjectNamePrefix corresponds to the path prefix of an object name.

func (*ObjectNamePrefix) Catalog 

func (tp *ObjectNamePrefix) Catalog() string

Catalog retrieves the unqualified catalog name.

func (*ObjectNamePrefix) Format 

func (tp *ObjectNamePrefix) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ObjectNamePrefix) Resolve 

func (tp *ObjectNamePrefix) Resolve(
	ctx context.Context, r ObjectNameTargetResolver, curDb string, searchPath sessiondata.SearchPath,
) (found bool, scMeta SchemaMeta, err error)

Resolve is used for table prefixes. This is adequate for table patterns with stars, e.g. AllTablesSelector.

func (*ObjectNamePrefix) Schema 

func (tp *ObjectNamePrefix) Schema() string

Schema retrieves the unqualified schema name.

func (*ObjectNamePrefix) String 

func (tp *ObjectNamePrefix) String() string

type ObjectNameTargetResolver 

type ObjectNameTargetResolver interface {
	LookupSchema(ctx context.Context, dbName, scName string) (found bool, scMeta SchemaMeta, err error)
}

ObjectNameTargetResolver is the helper interface to resolve object names when the object is not expected to exist.

TODO(ajwerner): figure out what scMeta is supposed to be. Currently it's the database but with User-defined schemas, should it be the schema? Should it be both?

type ObserverStatement 

type ObserverStatement interface {
	// contains filtered or unexported methods
}

ObserverStatement is a marker interface for statements which are allowed to run regardless of the current transaction state: statements other than rollback are generally rejected if the session is in a failed transaction state, but it's convenient to allow some statements (e.g. "show syntax; set tracing"). Such statements are not expected to modify the database, the transaction or session state (other than special cases such as enabling/disabling tracing).

These statements short-circuit the regular execution - they don't get planned (there are no corresponding planNodes). The connExecutor recognizes them and handles them.

type OnConflict 

type OnConflict struct {
	Columns   NameList
	Exprs     UpdateExprs
	Where     *Where
	DoNothing bool
}

OnConflict represents an `ON CONFLICT (columns) DO UPDATE SET exprs WHERE where` clause.

The zero value for OnConflict is used to signal the UPSERT short form, which uses the primary key for as the conflict index and the values being inserted for Exprs.

func (*OnConflict) IsUpsertAlias 

func (oc *OnConflict) IsUpsertAlias() bool

IsUpsertAlias returns true if the UPSERT syntactic sugar was used.

type OnJoinCond 

type OnJoinCond struct {
	Expr Expr
}

OnJoinCond represents an ON join condition.

func (*OnJoinCond) Format 

func (node *OnJoinCond) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type Operator 

type Operator interface {
	// contains filtered or unexported methods
}

Operator is used to identify Operators; used in sql.y.

type OrExpr 

type OrExpr struct {
	Left, Right Expr
	// contains filtered or unexported fields
}

OrExpr represents an OR expression.

func NewTypedOrExpr 

func NewTypedOrExpr(left, right TypedExpr) *OrExpr

NewTypedOrExpr returns a new OrExpr that is verified to be well-typed.

func (*OrExpr) Eval 

func (expr *OrExpr) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*OrExpr) Format 

func (node *OrExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (OrExpr) ResolvedType 

func (ta OrExpr) ResolvedType() *types.T

func (*OrExpr) String 

func (node *OrExpr) String() string

func (*OrExpr) TypeCheck 

func (expr *OrExpr) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*OrExpr) TypedLeft 

func (node *OrExpr) TypedLeft() TypedExpr

TypedLeft returns the OrExpr's left expression as a TypedExpr.

func (*OrExpr) TypedRight 

func (node *OrExpr) TypedRight() TypedExpr

TypedRight returns the OrExpr's right expression as a TypedExpr.

func (*OrExpr) Walk 

func (expr *OrExpr) Walk(v Visitor) Expr

Walk implements the Expr interface.

type Order 

type Order struct {
	OrderType  OrderType
	Expr       Expr
	Direction  Direction
	NullsOrder NullsOrder
	// Table/Index replaces Expr when OrderType = OrderByIndex.
	Table TableName
	// If Index is empty, then the order should use the primary key.
	Index UnrestrictedName
}

Order represents an ordering expression.

func (*Order) Equal 

func (node *Order) Equal(other *Order) bool

Equal checks if the node ordering is equivalent to other.

func (*Order) Format 

func (node *Order) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type OrderBy 

type OrderBy []*Order

OrderBy represents an ORDER BY clause.

func (*OrderBy) Format 

func (node *OrderBy) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type OrderType 

type OrderType int

OrderType indicates which type of expression is used in ORDER BY. 

const (
	// OrderByColumn is the regular "by expression/column" ORDER BY specification.
	OrderByColumn OrderType = iota
	// OrderByIndex enables the user to specify a given index' columns implicitly.
	OrderByIndex
)

type Overload 

type Overload struct {
	Types      TypeList
	ReturnType ReturnTyper
	Volatility Volatility

	// PreferredOverload determines overload resolution as follows.
	// When multiple overloads are eligible based on types even after all of of
	// the heuristics to pick one have been used, if one of the overloads is a
	// Overload with the `PreferredOverload` flag set to true it can be selected
	// rather than returning a no-such-method error.
	// This should generally be avoided -- avoiding introducing ambiguous
	// overloads in the first place is a much better solution -- and only done
	// after consultation with @knz @nvanbenschoten.
	PreferredOverload bool

	// Info is a description of the function, which is surfaced on the CockroachDB
	// docs site on the "Functions and Operators" page. Descriptions typically use
	// third-person with the function as an implicit subject (e.g. "Calculates
	// infinity"), but should focus more on ease of understanding so other structures
	// might be more appropriate.
	Info string

	AggregateFunc func([]*types.T, *EvalContext, Datums) AggregateFunc
	WindowFunc    func([]*types.T, *EvalContext) WindowFunc
	Fn            func(*EvalContext, Datums) (Datum, error)
	Generator     GeneratorFactory

	// SQLFn must be set for overloads of type SQLClass. It should return a SQL
	// statement which will be executed as a common table expression in the query.
	SQLFn func(*EvalContext, Datums) (string, error)

	// SpecializedVecBuiltin is used to let the vectorized engine
	// know when an Overload has a specialized vectorized operator.
	SpecializedVecBuiltin SpecializedVectorizedBuiltin

	// IgnoreVolatilityCheck ignores checking the functions overload's
	// volatility against Postgres's volatility at test time.
	// This should be used with caution.
	IgnoreVolatilityCheck bool
	// contains filtered or unexported fields
}

Overload is one of the overloads of a built-in function. Each FunctionDefinition may contain one or more overloads.

func (Overload) FixedReturnType 

func (b Overload) FixedReturnType() *types.T

FixedReturnType returns a fixed type that the function returns, returning Any if the return type is based on the function's arguments.

func (Overload) Signature 

func (b Overload) Signature(simplify bool) string

Signature returns a human-readable signature. If simplify is bool, tuple-returning functions with just 1 tuple element unwrap the return type in the signature.

type ParenExpr 

type ParenExpr struct {
	Expr Expr
	// contains filtered or unexported fields
}

ParenExpr represents a parenthesized expression.

func (*ParenExpr) Eval 

func (expr *ParenExpr) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*ParenExpr) Format 

func (node *ParenExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (ParenExpr) ResolvedType 

func (ta ParenExpr) ResolvedType() *types.T

func (*ParenExpr) String 

func (node *ParenExpr) String() string

func (*ParenExpr) TypeCheck 

func (expr *ParenExpr) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*ParenExpr) TypedInnerExpr 

func (node *ParenExpr) TypedInnerExpr() TypedExpr

TypedInnerExpr returns the ParenExpr's inner expression as a TypedExpr.

func (*ParenExpr) Walk 

func (expr *ParenExpr) Walk(v Visitor) Expr

Walk implements the Expr interface.

type ParenSelect 

type ParenSelect struct {
	Select *Select
}

ParenSelect represents a parenthesized SELECT/UNION/VALUES statement.

func (*ParenSelect) Format 

func (node *ParenSelect) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ParenSelect) StatementTag 

func (*ParenSelect) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ParenSelect) StatementType 

func (*ParenSelect) StatementType() StatementType

StatementType implements the Statement interface.

func (*ParenSelect) String 

func (n *ParenSelect) String() string

type ParenTableExpr 

type ParenTableExpr struct {
	Expr TableExpr
}

ParenTableExpr represents a parenthesized TableExpr.

func (*ParenTableExpr) Format 

func (node *ParenTableExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ParenTableExpr) String 

func (node *ParenTableExpr) String() string

type ParseTimeContext 

type ParseTimeContext interface {
	// GetRelativeParseTime returns the transaction time in the session's
	// timezone (i.e. now()). This is used to calculate relative dates,
	// like "tomorrow", and also provides a default time.Location for
	// parsed times.
	GetRelativeParseTime() time.Time
}

ParseTimeContext provides the information necessary for parsing dates, times, and timestamps. A nil value is generally acceptable and will result in reasonable defaults being applied.

func NewParseTimeContext 

func NewParseTimeContext(relativeParseTime time.Time) ParseTimeContext

NewParseTimeContext constructs a ParseTimeContext that returns the given values.

type PartitionBy 

type PartitionBy struct {
	Fields NameList
	// Exactly one of List or Range is required to be non-empty.
	List  []ListPartition
	Range []RangePartition
}

PartitionBy represents an PARTITION BY definition within a CREATE/ALTER TABLE/INDEX statement.

func (*PartitionBy) Format 

func (node *PartitionBy) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type PartitionByType 

type PartitionByType string

PartitionByType is an enum of each type of partitioning (LIST/RANGE). 

const (
	// PartitionByList indicates a PARTITION BY LIST clause.
	PartitionByList PartitionByType = "LIST"
	// PartitionByRange indicates a PARTITION BY LIST clause.
	PartitionByRange PartitionByType = "RANGE"
)

type PartitionMaxVal 

type PartitionMaxVal struct{}

PartitionMaxVal represents the MAXVALUE expression.

func (PartitionMaxVal) Format 

func (node PartitionMaxVal) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (PartitionMaxVal) String 

func (node PartitionMaxVal) String() string

func (PartitionMaxVal) TypeCheck 

func (expr PartitionMaxVal) TypeCheck(
	_ context.Context, _ *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (PartitionMaxVal) Walk 

func (expr PartitionMaxVal) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type PartitionMinVal 

type PartitionMinVal struct{}

PartitionMinVal represents the MINVALUE expression.

func (PartitionMinVal) Format 

func (node PartitionMinVal) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (PartitionMinVal) String 

func (node PartitionMinVal) String() string

func (PartitionMinVal) TypeCheck 

func (expr PartitionMinVal) TypeCheck(
	_ context.Context, _ *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (PartitionMinVal) Walk 

func (expr PartitionMinVal) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type PartitionedBackup 

type PartitionedBackup []Expr

PartitionedBackup is a list of destination URIs for a single BACKUP. A single URI corresponds to the special case of a regular backup, and multiple URIs correspond to a partitioned backup whose locality configuration is specified by LOCALITY url params.

func (*PartitionedBackup) Format 

func (node *PartitionedBackup) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type PeerGroupChecker 

type PeerGroupChecker interface {
	InSameGroup(i, j int) (bool, error)
}

PeerGroupChecker can check if a pair of row indices within a partition are in the same peer group. It also returns an error if it occurs while checking the peer groups.

type PeerGroupsIndicesHelper 

type PeerGroupsIndicesHelper struct {
	// contains filtered or unexported fields
}

PeerGroupsIndicesHelper computes peer groups using the given PeerGroupChecker. In ROWS and RANGE modes, it processes one peer group at a time and stores information only about single peer group. In GROUPS mode, it's behavior depends on the frame bounds; in the worst case, it stores max(F, O) peer groups at the same time, where F is the maximum number of peer groups within the frame at any point and O is the maximum of two offsets if we have OFFSET_FOLLOWING type of bound (both F and O are upper-bounded by total number of peer groups).

func (*PeerGroupsIndicesHelper) GetFirstPeerIdx 

func (p *PeerGroupsIndicesHelper) GetFirstPeerIdx(peerGroupNum int) int

GetFirstPeerIdx returns index of the first peer within peer group of number peerGroupNum (counting from 0).

func (*PeerGroupsIndicesHelper) GetLastPeerGroupNum 

func (p *PeerGroupsIndicesHelper) GetLastPeerGroupNum() int

GetLastPeerGroupNum returns the number of the last peer group in the queue.

func (*PeerGroupsIndicesHelper) GetRowCount 

func (p *PeerGroupsIndicesHelper) GetRowCount(peerGroupNum int) int

GetRowCount returns the number of rows within peer group of number peerGroupNum (counting from 0).

func (*PeerGroupsIndicesHelper) Init 

func (p *PeerGroupsIndicesHelper) Init(wfr *WindowFrameRun, peerGrouper PeerGroupChecker) error

Init computes all peer groups necessary to perform calculations of a window function over the first row of the partition. It returns any error if it occurs.

func (*PeerGroupsIndicesHelper) Update 

func (p *PeerGroupsIndicesHelper) Update(wfr *WindowFrameRun) error

Update should be called after a window function has been computed over all rows in wfr.CurRowPeerGroupNum peer group. If not all rows have been already processed, it computes the next peer group. It returns any error if it occurs.

type Placeholder 

type Placeholder struct {
	Idx PlaceholderIdx
	// contains filtered or unexported fields
}

Placeholder represents a named placeholder.

func NewPlaceholder 

func NewPlaceholder(name string) (*Placeholder, error)

NewPlaceholder allocates a Placeholder.

func (*Placeholder) AmbiguousFormat 

func (d *Placeholder) AmbiguousFormat() bool

AmbiguousFormat implements the Datum interface.

func (*Placeholder) Compare 

func (d *Placeholder) Compare(ctx *EvalContext, other Datum) int

Compare implements the Datum interface.

func (*Placeholder) Eval 

func (t *Placeholder) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*Placeholder) Format 

func (node *Placeholder) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Placeholder) IsMax 

func (d *Placeholder) IsMax(ctx *EvalContext) bool

IsMax implements the Datum interface.

func (*Placeholder) IsMin 

func (d *Placeholder) IsMin(ctx *EvalContext) bool

IsMin implements the Datum interface.

func (*Placeholder) Max 

func (d *Placeholder) Max(ctx *EvalContext) (Datum, bool)

Max implements the Datum interface.

func (*Placeholder) Min 

func (d *Placeholder) Min(ctx *EvalContext) (Datum, bool)

Min implements the Datum interface.

func (*Placeholder) Next 

func (d *Placeholder) Next(ctx *EvalContext) (Datum, bool)

Next implements the Datum interface.

func (*Placeholder) Prev 

func (d *Placeholder) Prev(ctx *EvalContext) (Datum, bool)

Prev implements the Datum interface.

func (*Placeholder) ResolvedType 

func (node *Placeholder) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*Placeholder) Size 

func (d *Placeholder) Size() uintptr

Size implements the Datum interface.

func (*Placeholder) String 

func (node *Placeholder) String() string

func (*Placeholder) TypeCheck 

func (expr *Placeholder) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*Placeholder) Walk 

func (expr *Placeholder) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type PlaceholderIdx 

type PlaceholderIdx uint16

PlaceholderIdx is the 0-based index of a placeholder. Placeholder "$1" has PlaceholderIdx=0.

func (PlaceholderIdx) String 

func (idx PlaceholderIdx) String() string

String returns the index as a placeholder string representation ($1, $2 etc).

type PlaceholderInfo 

type PlaceholderInfo struct {
	PlaceholderTypesInfo

	Values QueryArguments
}

PlaceholderInfo defines the interface to SQL placeholders.

func (*PlaceholderInfo) Assign 

func (p *PlaceholderInfo) Assign(src *PlaceholderInfo, numPlaceholders int) error

Assign resets the PlaceholderInfo to the contents of src. If src is nil, a new structure is initialized.

func (*PlaceholderInfo) Init 

func (p *PlaceholderInfo) Init(numPlaceholders int, typeHints PlaceholderTypes) error

Init initializes a PlaceholderInfo structure appropriate for the given number of placeholders, and with the given (optional) type hints.

func (*PlaceholderInfo) IsUnresolvedPlaceholder 

func (p *PlaceholderInfo) IsUnresolvedPlaceholder(expr Expr) bool

IsUnresolvedPlaceholder returns whether expr is an unresolved placeholder. In other words, it returns whether the provided expression is a placeholder expression or a placeholder expression within nested parentheses, and if so, whether the placeholder's type remains unset in the PlaceholderInfo.

func (*PlaceholderInfo) Value 

func (p *PlaceholderInfo) Value(idx PlaceholderIdx) (TypedExpr, bool)

Value returns the known value of a placeholder. Returns false in the 2nd value if the placeholder does not have a value.

type PlaceholderTypes 

type PlaceholderTypes []*types.T

PlaceholderTypes stores placeholder types (or type hints), one per PlaceholderIdx. The slice is always pre-allocated to the number of placeholders in the statement. Entries that don't yet have a type are nil.

func (PlaceholderTypes) AssertAllSet 

func (pt PlaceholderTypes) AssertAllSet() error

AssertAllSet verifies that all types have been set and returns an error otherwise.

func (PlaceholderTypes) Equals 

func (pt PlaceholderTypes) Equals(other PlaceholderTypes) bool

Equals returns true if two PlaceholderTypes contain the same types.

type PlaceholderTypesInfo 

type PlaceholderTypesInfo struct {
	// TypeHints contains the initially set type hints for each placeholder if
	// present. It is not changed during query type checking.
	TypeHints PlaceholderTypes
	// Types contains the final types set for each placeholder after type
	// checking.
	Types PlaceholderTypes
}

PlaceholderTypesInfo encapsulates typing information for placeholders.

func (*PlaceholderTypesInfo) SetType 

func (p *PlaceholderTypesInfo) SetType(idx PlaceholderIdx, typ *types.T) error

SetType assigns a known type to a placeholder. Reports an error if another type was previously assigned.

func (*PlaceholderTypesInfo) Type 

func (p *PlaceholderTypesInfo) Type(idx PlaceholderIdx) (_ *types.T, ok bool)

Type returns the known type of a placeholder. If there is no known type yet but there is a type hint, returns the type hint.

func (*PlaceholderTypesInfo) ValueType 

func (p *PlaceholderTypesInfo) ValueType(idx PlaceholderIdx) (_ *types.T, ok bool)

ValueType returns the type of the value that must be supplied for a placeholder. This is the type hint given by the client if there is one, or the placeholder type if there isn't one. This can differ from Type(idx) when a client hint is overridden (see Placeholder.Eval).

type Prepare 

type Prepare struct {
	Name      Name
	Types     []ResolvableTypeReference
	Statement Statement
}

Prepare represents a PREPARE statement.

func (*Prepare) Format 

func (node *Prepare) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Prepare) StatementTag 

func (*Prepare) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Prepare) StatementType 

func (*Prepare) StatementType() StatementType

StatementType implements the Statement interface.

func (*Prepare) String 

func (n *Prepare) String() string

type PrettyAlignMode 

type PrettyAlignMode int

PrettyAlignMode directs which alignment mode to use.

TODO(knz/mjibson): this variety of options currently exists so as to enable comparisons and gauging individual preferences. We should aim to remove some or all of these options in the future.

type PrettyCfg 

type PrettyCfg struct {
	// LineWidth is the desired maximum line width.
	LineWidth int
	// TabWidth is the amount of spaces to use for tabs when UseTabs is
	// false.
	TabWidth int
	// Align, when set to another value than PrettyNoAlign, uses
	// alignment for some constructs as a first choice. If not set or if
	// the line width is insufficient, nesting is used instead.
	Align PrettyAlignMode
	// UseTabs indicates whether to use tab chars to signal indentation.
	UseTabs bool
	// Simplify, when set, removes extraneous parentheses.
	Simplify bool
	// Case, if set, transforms case-insensitive strings (like SQL keywords).
	Case func(string) string
	// JSONFmt, when set, pretty-prints strings that are asserted or cast
	// to JSON.
	JSONFmt bool
}

PrettyCfg holds configuration for pretty printing statements.

func DefaultPrettyCfg 

func DefaultPrettyCfg() PrettyCfg

DefaultPrettyCfg returns a PrettyCfg with the default configuration.

func (*PrettyCfg) Doc 

func (p *PrettyCfg) Doc(f NodeFormatter) pretty.Doc

Doc converts f (generally a Statement) to a pretty.Doc. If f does not have a native conversion, its .Format representation is used as a simple Text Doc.

func (*PrettyCfg) Pretty 

func (p *PrettyCfg) Pretty(stmt NodeFormatter) string

Pretty pretty prints stmt with specified options.

type PrimaryKeyConstraint 

type PrimaryKeyConstraint struct{}

PrimaryKeyConstraint represents PRIMARY KEY on a column.

type PrivilegedAccessor 

type PrivilegedAccessor interface {
	// LookupNamespaceID returns the id of the namespace given it's parent id and name.
	// It is meant as a replacement for looking up the system.namespace directly.
	// Returns the id, a bool representing whether the namespace exists, and an error
	// if there is one.
	LookupNamespaceID(
		ctx context.Context, parentID int64, name string,
	) (DInt, bool, error)

	// LookupZoneConfig returns the zone config given a namespace id.
	// It is meant as a replacement for looking up system.zones directly.
	// Returns the config byte array, a bool representing whether the namespace exists,
	// and an error if there is one.
	LookupZoneConfigByNamespaceID(ctx context.Context, id int64) (DBytes, bool, error)
}

PrivilegedAccessor gives access to certain queries that would otherwise require someone with RootUser access to query a given data source. It is defined independently to prevent a circular dependency on sql, tree and sqlbase.

type QueryArguments 

type QueryArguments []TypedExpr

QueryArguments stores query arguments, one per PlaceholderIdx.

A nil value represents a NULL argument.

func (QueryArguments) String 

func (qa QueryArguments) String() string

type RangeCond 

type RangeCond struct {
	Not       bool
	Symmetric bool
	Left      Expr
	From, To  Expr
	// contains filtered or unexported fields
}

RangeCond represents a BETWEEN [SYMMETRIC] or a NOT BETWEEN [SYMMETRIC] expression.

func (*RangeCond) Eval 

func (expr *RangeCond) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*RangeCond) Format 

func (node *RangeCond) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (RangeCond) ResolvedType 

func (ta RangeCond) ResolvedType() *types.T

func (*RangeCond) String 

func (node *RangeCond) String() string

func (*RangeCond) TypeCheck 

func (expr *RangeCond) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*RangeCond) TypedFrom 

func (node *RangeCond) TypedFrom() TypedExpr

TypedFrom returns the RangeCond's from expression as a TypedExpr.

func (*RangeCond) TypedLeftFrom 

func (node *RangeCond) TypedLeftFrom() TypedExpr

TypedLeftFrom returns the RangeCond's left expression as a TypedExpr, in the context of a comparison with TypedFrom().

func (*RangeCond) TypedLeftTo 

func (node *RangeCond) TypedLeftTo() TypedExpr

TypedLeftTo returns the RangeCond's left expression as a TypedExpr, in the context of a comparison with TypedTo().

func (*RangeCond) TypedTo 

func (node *RangeCond) TypedTo() TypedExpr

TypedTo returns the RangeCond's to expression as a TypedExpr.

func (*RangeCond) Walk 

func (expr *RangeCond) Walk(v Visitor) Expr

Walk implements the Expr interface.

type RangePartition 

type RangePartition struct {
	Name         UnrestrictedName
	From         Exprs
	To           Exprs
	Subpartition *PartitionBy
}

RangePartition represents a PARTITION definition within a PARTITION BY RANGE.

func (*RangePartition) Format 

func (node *RangePartition) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type ReadWriteMode 

type ReadWriteMode int

ReadWriteMode holds the read write mode for a transaction. 

const (
	UnspecifiedReadWriteMode ReadWriteMode = iota
	ReadOnly
	ReadWrite
)

ReadWriteMode values

func (ReadWriteMode) String 

func (ro ReadWriteMode) String() string

type ReferenceAction 

type ReferenceAction int

ReferenceAction is the method used to maintain referential integrity through foreign keys. 

const (
	NoAction ReferenceAction = iota
	Restrict
	SetNull
	SetDefault
	Cascade
)

The values for ReferenceAction.

func (ReferenceAction) String 

func (ra ReferenceAction) String() string

type ReferenceActions 

type ReferenceActions struct {
	Delete ReferenceAction
	Update ReferenceAction
}

ReferenceActions contains the actions specified to maintain referential integrity through foreign keys for different operations.

func (*ReferenceActions) Format 

func (node *ReferenceActions) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type RegexpCache 

type RegexpCache struct {
	// contains filtered or unexported fields
}

A RegexpCache is a cache used to store compiled regular expressions. The cache is safe for concurrent use by multiple goroutines. It is also safe to use the cache through a nil reference, where it will act like a valid cache with no capacity.

func NewRegexpCache 

func NewRegexpCache(size int) *RegexpCache

NewRegexpCache creates a new RegexpCache of the given size. The underlying cache internally uses a hash map, so lookups are cheap.

func (*RegexpCache) GetRegexp 

func (rc *RegexpCache) GetRegexp(key RegexpCacheKey) (*regexp.Regexp, error)

GetRegexp consults the cache for the regular expressions stored for the given key, compiling the key's pattern if it is not already in the cache.

func (*RegexpCache) Len 

func (rc *RegexpCache) Len() int

Len returns the number of compiled regular expressions in the cache.

type RegexpCacheKey 

type RegexpCacheKey interface {
	Pattern() (string, error)
}

RegexpCacheKey allows cache keys to take the form of different types, as long as they are comparable and can produce a pattern when needed for regexp compilation. The pattern method will not be called until after a cache lookup is performed and the result is a miss.

type ReleaseSavepoint 

type ReleaseSavepoint struct {
	Savepoint Name
}

ReleaseSavepoint represents a RELEASE SAVEPOINT <name> statement.

func (*ReleaseSavepoint) Format 

func (node *ReleaseSavepoint) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ReleaseSavepoint) StatementTag 

func (*ReleaseSavepoint) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ReleaseSavepoint) StatementType 

func (*ReleaseSavepoint) StatementType() StatementType

StatementType implements the Statement interface.

func (*ReleaseSavepoint) String 

func (n *ReleaseSavepoint) String() string

type Relocate 

type Relocate struct {
	// TODO(a-robinson): It's not great that this can only work on ranges that
	// are part of a currently valid table or index.
	TableOrIndex TableIndexName
	// Each row contains an array with store ids and values for the columns in the
	// PK or index (or a prefix of the columns).
	// See docs/RFCS/sql_split_syntax.md.
	Rows          *Select
	RelocateLease bool
}

Relocate represents an `ALTER TABLE/INDEX .. EXPERIMENTAL_RELOCATE ..` statement.

func (*Relocate) Format 

func (node *Relocate) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Relocate) StatementTag 

func (n *Relocate) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Relocate) StatementType 

func (*Relocate) StatementType() StatementType

StatementType implements the Statement interface.

func (*Relocate) String 

func (n *Relocate) String() string

type RenameColumn 

type RenameColumn struct {
	Table   TableName
	Name    Name
	NewName Name
	// IfExists refers to the table, not the column.
	IfExists bool
}

RenameColumn represents a RENAME COLUMN statement.

func (*RenameColumn) Format 

func (node *RenameColumn) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*RenameColumn) StatementTag 

func (*RenameColumn) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*RenameColumn) StatementType 

func (*RenameColumn) StatementType() StatementType

StatementType implements the Statement interface.

func (*RenameColumn) String 

func (n *RenameColumn) String() string

type RenameDatabase 

type RenameDatabase struct {
	Name    Name
	NewName Name
}

RenameDatabase represents a RENAME DATABASE statement.

func (*RenameDatabase) Format 

func (node *RenameDatabase) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*RenameDatabase) StatementTag 

func (*RenameDatabase) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*RenameDatabase) StatementType 

func (*RenameDatabase) StatementType() StatementType

StatementType implements the Statement interface.

func (*RenameDatabase) String 

func (n *RenameDatabase) String() string

type RenameIndex 

type RenameIndex struct {
	Index    *TableIndexName
	NewName  UnrestrictedName
	IfExists bool
}

RenameIndex represents a RENAME INDEX statement.

func (*RenameIndex) Format 

func (node *RenameIndex) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*RenameIndex) StatementTag 

func (*RenameIndex) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*RenameIndex) StatementType 

func (*RenameIndex) StatementType() StatementType

StatementType implements the Statement interface.

func (*RenameIndex) String 

func (n *RenameIndex) String() string

type RenameTable 

type RenameTable struct {
	Name       *UnresolvedObjectName
	NewName    *UnresolvedObjectName
	IfExists   bool
	IsView     bool
	IsSequence bool
}

RenameTable represents a RENAME TABLE or RENAME VIEW or RENAME SEQUENCE statement. Whether the user has asked to rename a view or a sequence is indicated by the IsView and IsSequence fields.

func (*RenameTable) Format 

func (node *RenameTable) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*RenameTable) StatementTag 

func (n *RenameTable) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*RenameTable) StatementType 

func (*RenameTable) StatementType() StatementType

StatementType implements the Statement interface.

func (*RenameTable) String 

func (n *RenameTable) String() string

type RequiredTableKind 

type RequiredTableKind int

RequiredTableKind controls what kind of TableDescriptor backed object is requested to be resolved. 

const (
	ResolveAnyTableKind RequiredTableKind = iota
	ResolveRequireTableDesc
	ResolveRequireViewDesc
	ResolveRequireTableOrViewDesc
	ResolveRequireSequenceDesc
)

RequiredTableKind options have descriptive names.

func (RequiredTableKind) String 

func (r RequiredTableKind) String() string

type ResolvableFunctionReference 

type ResolvableFunctionReference struct {
	FunctionReference
}

ResolvableFunctionReference implements the editable reference cell of a FuncExpr. The FunctionRerence is updated by the Normalize() method.

func WrapFunction 

func WrapFunction(n string) ResolvableFunctionReference

WrapFunction creates a new ResolvableFunctionReference holding a pre-resolved function. Helper for grammar rules.

func (*ResolvableFunctionReference) Format 

func (fn *ResolvableFunctionReference) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ResolvableFunctionReference) Resolve 

func (fn *ResolvableFunctionReference) Resolve(
	searchPath sessiondata.SearchPath,
) (*FunctionDefinition, error)

Resolve checks if the function name is already resolved and resolves it as necessary.

func (*ResolvableFunctionReference) String 

func (fn *ResolvableFunctionReference) String() string

type ResolvableTypeReference 

type ResolvableTypeReference interface {
	SQLString() string
}

ResolvableTypeReference represents a type that is possibly unknown until type-checking/type name resolution is performed. N.B. ResolvableTypeReferences in expressions must be formatted with FormatTypeReference instead of SQLString.

type Restore 

type Restore struct {
	Targets            TargetList
	DescriptorCoverage DescriptorCoverage
	From               []PartitionedBackup
	AsOf               AsOfClause
	Options            KVOptions
}

Restore represents a RESTORE statement.

func (*Restore) Format 

func (node *Restore) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Restore) StatementTag 

func (*Restore) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Restore) StatementType 

func (*Restore) StatementType() StatementType

StatementType implements the Statement interface.

func (*Restore) String 

func (n *Restore) String() string

type ReturnTyper 

type ReturnTyper func(args []TypedExpr) *types.T

ReturnTyper defines the type-level function in which a builtin function's return type is determined. ReturnTypers should make sure to return unknownReturnType when necessary.

func ArrayOfFirstNonNullReturnType 

func ArrayOfFirstNonNullReturnType() ReturnTyper

ArrayOfFirstNonNullReturnType returns an array type from the first non-null type in the argument list.

func FirstNonNullReturnType 

func FirstNonNullReturnType() ReturnTyper

FirstNonNullReturnType returns the type of the first non-null argument, or types.Unknown if all arguments are null. There must be at least one argument, or else FirstNonNullReturnType returns UnknownReturnType. This method is used with HomogeneousType functions, in which all arguments have been checked to have the same type (or be null).

func FixedReturnType 

func FixedReturnType(typ *types.T) ReturnTyper

FixedReturnType functions simply return a fixed type, independent of argument types.

func IdentityReturnType 

func IdentityReturnType(idx int) ReturnTyper

IdentityReturnType creates a returnType that is a projection of the idx'th argument type.

type ReturningClause 

type ReturningClause interface {
	NodeFormatter
	// contains filtered or unexported methods
}

ReturningClause represents the returning clause on a statement.

type ReturningExprs 

type ReturningExprs SelectExprs

ReturningExprs represents RETURNING expressions.

func (*ReturningExprs) Format 

func (r *ReturningExprs) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type ReturningNothing 

type ReturningNothing struct{}

ReturningNothing represents RETURNING NOTHING.

func (*ReturningNothing) Format 

func (*ReturningNothing) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type Revoke 

type Revoke struct {
	Privileges privilege.List
	Targets    TargetList
	Grantees   NameList
}

Revoke represents a REVOKE statement. PrivilegeList and TargetList are defined in grant.go

func (*Revoke) Format 

func (node *Revoke) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Revoke) StatementTag 

func (*Revoke) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Revoke) StatementType 

func (*Revoke) StatementType() StatementType

StatementType implements the Statement interface.

func (*Revoke) String 

func (n *Revoke) String() string

type RevokeRole 

type RevokeRole struct {
	Roles       NameList
	Members     NameList
	AdminOption bool
}

RevokeRole represents a REVOKE <role> statement.

func (*RevokeRole) Format 

func (node *RevokeRole) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*RevokeRole) StatementTag 

func (*RevokeRole) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*RevokeRole) StatementType 

func (*RevokeRole) StatementType() StatementType

StatementType implements the Statement interface.

func (*RevokeRole) String 

func (n *RevokeRole) String() string

type RollbackToSavepoint 

type RollbackToSavepoint struct {
	Savepoint Name
}

RollbackToSavepoint represents a ROLLBACK TO SAVEPOINT <name> statement.

func (*RollbackToSavepoint) Format 

func (node *RollbackToSavepoint) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*RollbackToSavepoint) StatementTag 

func (*RollbackToSavepoint) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*RollbackToSavepoint) StatementType 

func (*RollbackToSavepoint) StatementType() StatementType

StatementType implements the Statement interface.

func (*RollbackToSavepoint) String 

func (n *RollbackToSavepoint) String() string

type RollbackTransaction 

type RollbackTransaction struct{}

RollbackTransaction represents a ROLLBACK statement.

func (*RollbackTransaction) Format 

func (node *RollbackTransaction) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*RollbackTransaction) StatementTag 

func (*RollbackTransaction) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*RollbackTransaction) StatementType 

func (*RollbackTransaction) StatementType() StatementType

StatementType implements the Statement interface.

func (*RollbackTransaction) String 

func (n *RollbackTransaction) String() string

type RowsFromExpr 

type RowsFromExpr struct {
	Items Exprs
}

RowsFromExpr represents a ROWS FROM(...) expression.

func (*RowsFromExpr) Format 

func (node *RowsFromExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type Savepoint 

type Savepoint struct {
	Name Name
}

Savepoint represents a SAVEPOINT <name> statement.

func (*Savepoint) Format 

func (node *Savepoint) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Savepoint) StatementTag 

func (*Savepoint) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Savepoint) StatementType 

func (*Savepoint) StatementType() StatementType

StatementType implements the Statement interface.

func (*Savepoint) String 

func (n *Savepoint) String() string

type ScalarProperties 

type ScalarProperties struct {
	// SeenAggregate is set to true if the expression originally
	// contained an aggregation.
	SeenAggregate bool

	// SeenWindowApplication is set to true if the expression originally
	// contained a window function.
	SeenWindowApplication bool

	// SeenGenerator is set to true if the expression originally
	// contained a SRF.
	SeenGenerator bool

	// InWindowFunc is temporarily set to true while type checking the
	// parameters of a window function in order to reject nested window
	// functions.
	InWindowFunc bool
	// contains filtered or unexported fields
}

ScalarProperties contains the properties of the current scalar expression discovered during semantic analysis. The properties are collected prior to simplification, so some of the properties may not hold anymore by the time semantic analysis completes.

func (*ScalarProperties) Clear 

func (sp *ScalarProperties) Clear()

Clear resets the scalar properties to defaults.

type Scatter 

type Scatter struct {
	TableOrIndex TableIndexName
	// Optional from and to values for the columns in the PK or index (or a prefix
	// of the columns).
	// See docs/RFCS/sql_split_syntax.md.
	From, To Exprs
}

Scatter represents an `ALTER TABLE/INDEX .. SCATTER ..` statement.

func (*Scatter) Format 

func (node *Scatter) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Scatter) StatementTag 

func (*Scatter) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Scatter) StatementType 

func (*Scatter) StatementType() StatementType

StatementType implements the Statement interface.

func (*Scatter) String 

func (n *Scatter) String() string

type ScheduledBackup 

type ScheduledBackup struct {
	ScheduleName    Expr
	Recurrence      Expr
	FullBackup      *FullBackupClause /* nil implies choose default */
	Targets         *TargetList       /* nil implies ast.AllDescriptors coverage */
	To              PartitionedBackup
	BackupOptions   BackupOptions
	ScheduleOptions KVOptions
}

ScheduledBackup represents scheduled backup job.

func (*ScheduledBackup) Format 

func (node *ScheduledBackup) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ScheduledBackup) StatementTag 

func (*ScheduledBackup) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ScheduledBackup) StatementType 

func (*ScheduledBackup) StatementType() StatementType

StatementType implements the Statement interface.

func (*ScheduledBackup) String 

func (n *ScheduledBackup) String() string

type SchemaMeta 

type SchemaMeta interface {
	// SchemaMeta is the interface anchor.
	SchemaMeta()
}

SchemaMeta is an opaque reference returned by LookupSchema().

type Scrub 

type Scrub struct {
	Typ     ScrubType
	Options ScrubOptions
	// Table is only set during SCRUB TABLE statements.
	Table *UnresolvedObjectName
	// Database is only set during SCRUB DATABASE statements.
	Database Name
	AsOf     AsOfClause
}

Scrub represents a SCRUB statement.

func (*Scrub) Format 

func (n *Scrub) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Scrub) StatementTag 

func (n *Scrub) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Scrub) StatementType 

func (*Scrub) StatementType() StatementType

StatementType implements the Statement interface.

func (*Scrub) String 

func (n *Scrub) String() string

type ScrubOption 

type ScrubOption interface {
	fmt.Stringer
	NodeFormatter
	// contains filtered or unexported methods
}

ScrubOption represents a scrub option.

type ScrubOptionConstraint 

type ScrubOptionConstraint struct {
	ConstraintNames NameList
}

ScrubOptionConstraint represents a CONSTRAINT scrub check.

func (*ScrubOptionConstraint) Format 

func (n *ScrubOptionConstraint) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ScrubOptionConstraint) String 

func (n *ScrubOptionConstraint) String() string

type ScrubOptionIndex 

type ScrubOptionIndex struct {
	IndexNames NameList
}

ScrubOptionIndex represents an INDEX scrub check.

func (*ScrubOptionIndex) Format 

func (n *ScrubOptionIndex) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ScrubOptionIndex) String 

func (n *ScrubOptionIndex) String() string

type ScrubOptionPhysical 

type ScrubOptionPhysical struct{}

ScrubOptionPhysical represents a PHYSICAL scrub check.

func (*ScrubOptionPhysical) Format 

func (n *ScrubOptionPhysical) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ScrubOptionPhysical) String 

func (n *ScrubOptionPhysical) String() string

type ScrubOptions 

type ScrubOptions []ScrubOption

ScrubOptions corresponds to a comma-delimited list of scrub options.

func (*ScrubOptions) Format 

func (n *ScrubOptions) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ScrubOptions) String 

func (n *ScrubOptions) String() string

type ScrubType 

type ScrubType int

ScrubType describes the SCRUB statement operation.

type Select 

type Select struct {
	With    *With
	Select  SelectStatement
	OrderBy OrderBy
	Limit   *Limit
	Locking LockingClause
}

Select represents a SelectStatement with an ORDER and/or LIMIT.

func (*Select) Format 

func (node *Select) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Select) StatementTag 

func (*Select) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Select) StatementType 

func (*Select) StatementType() StatementType

StatementType implements the Statement interface.

func (*Select) String 

func (n *Select) String() string

type SelectClause 

type SelectClause struct {
	Distinct    bool
	DistinctOn  DistinctOn
	Exprs       SelectExprs
	From        From
	Where       *Where
	GroupBy     GroupBy
	Having      *Where
	Window      Window
	TableSelect bool
}

SelectClause represents a SELECT statement.

func (*SelectClause) Format 

func (node *SelectClause) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*SelectClause) StatementTag 

func (*SelectClause) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*SelectClause) StatementType 

func (*SelectClause) StatementType() StatementType

StatementType implements the Statement interface.

func (*SelectClause) String 

func (n *SelectClause) String() string

type SelectExpr 

type SelectExpr struct {
	Expr Expr
	As   UnrestrictedName
}

SelectExpr represents a SELECT expression.

func StarSelectExpr 

func StarSelectExpr() SelectExpr

StarSelectExpr is a convenience function that represents an unqualified "*" in a select expression.

func (*SelectExpr) Format 

func (node *SelectExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*SelectExpr) NormalizeTopLevelVarName 

func (node *SelectExpr) NormalizeTopLevelVarName() error

NormalizeTopLevelVarName preemptively expands any UnresolvedName at the top level of the expression into a VarName. This is meant to catch stars so that sql.checkRenderStar() can see it prior to other expression transformations.

type SelectExprs 

type SelectExprs []SelectExpr

SelectExprs represents SELECT expressions.

func (*SelectExprs) Format 

func (node *SelectExprs) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type SelectStatement 

type SelectStatement interface {
	Statement
	// contains filtered or unexported methods
}

SelectStatement represents any SELECT statement.

type SemaContext 

type SemaContext struct {
	// Annotations augments the AST with extra information.
	Annotations Annotations

	// Placeholders relates placeholder names to their type and, later, value.
	Placeholders PlaceholderInfo

	// IVarContainer is used to resolve the types of IndexedVars.
	IVarContainer IndexedVarContainer

	// SearchPath indicates where to search for unqualified function
	// names. The path elements must be normalized via Name.Normalize()
	// already.
	SearchPath sessiondata.SearchPath

	// TypeResolver manages resolving type names into *types.T's.
	TypeResolver TypeReferenceResolver

	// AsOfTimestamp denotes the explicit AS OF SYSTEM TIME timestamp for the
	// query, if any. If the query is not an AS OF SYSTEM TIME query,
	// AsOfTimestamp is nil.
	// TODO(knz): we may want to support table readers at arbitrary
	// timestamps, so that each FROM clause can have its own
	// timestamp. In that case, the timestamp would not be set
	// globally for the entire txn and this field would not be needed.
	AsOfTimestamp *hlc.Timestamp

	Properties SemaProperties
}

SemaContext defines the context in which to perform semantic analysis on an expression syntax ast.

func MakeSemaContext 

func MakeSemaContext() SemaContext

MakeSemaContext initializes a simple SemaContext suitable for "lightweight" type checking such as the one performed for default expressions. Note: if queries with placeholders are going to be used, SemaContext.Placeholders.Init must be called separately.

func (*SemaContext) GetTypeResolver 

func (sc *SemaContext) GetTypeResolver() TypeReferenceResolver

GetTypeResolver returns the TypeReferenceResolver.

type SemaProperties 

type SemaProperties struct {

	// Derived is populated during semantic analysis with properties
	// from the expression being analyzed.  The caller is responsible
	// for re-initializing this when needed.
	Derived ScalarProperties
	// contains filtered or unexported fields
}

SemaProperties is a holder for required and derived properties during semantic analysis. It provides scoping semantics via its Restore() method, see below.

func (*SemaProperties) IsSet 

func (s *SemaProperties) IsSet(rejectFlags SemaRejectFlags) bool

IsSet checks if the given rejectFlag is set as a required property.

func (*SemaProperties) Require 

func (s *SemaProperties) Require(context string, rejectFlags SemaRejectFlags)

Require resets the derived properties and sets required constraints.

func (*SemaProperties) Restore 

func (s *SemaProperties) Restore(orig SemaProperties)

Restore restores a copy of a SemaProperties. Use with: defer semaCtx.Properties.Restore(semaCtx.Properties)

type SemaRejectFlags 

type SemaRejectFlags int

SemaRejectFlags contains flags to filter out certain kinds of expressions. 

const (
	// RejectAggregates rejects min(), max(), etc.
	RejectAggregates SemaRejectFlags = 1 << iota

	// RejectNestedAggregates rejects any use of aggregates inside the
	// argument list of another function call, which can itself be an aggregate
	// (RejectAggregates notwithstanding).
	RejectNestedAggregates

	// RejectNestedWindows rejects any use of window functions inside the
	// argument list of another window function.
	RejectNestedWindowFunctions

	// RejectWindowApplications rejects "x() over y", etc.
	RejectWindowApplications

	// RejectGenerators rejects any use of SRFs, e.g "generate_series()".
	RejectGenerators

	// RejectNestedGenerators rejects any use of SRFs inside the
	// argument list of another function call, which can itself be a SRF
	// (RejectGenerators notwithstanding).
	// This is used e.g. when processing the calls inside ROWS FROM.
	RejectNestedGenerators

	// RejectStableFunctions rejects any stable functions.
	RejectStableFunctions

	// RejectVolatileFunctions rejects any volatile functions.
	RejectVolatileFunctions

	// RejectSubqueries rejects subqueries in scalar contexts.
	RejectSubqueries

	// RejectSpecial is used in common places like the LIMIT clause.
	RejectSpecial = RejectAggregates | RejectGenerators | RejectWindowApplications
)

Valid values for SemaRejectFlags.

type SequenceOperators 

type SequenceOperators interface {
	EvalDatabase
	// IncrementSequence increments the given sequence and returns the result.
	// It returns an error if the given name is not a sequence.
	// The caller must ensure that seqName is fully qualified already.
	IncrementSequence(ctx context.Context, seqName *TableName) (int64, error)

	// GetLatestValueInSessionForSequence returns the value most recently obtained by
	// nextval() for the given sequence in this session.
	GetLatestValueInSessionForSequence(ctx context.Context, seqName *TableName) (int64, error)

	// SetSequenceValue sets the sequence's value.
	// If isCalled is false, the sequence is set such that the next time nextval() is called,
	// `newVal` is returned. Otherwise, the next call to nextval will return
	// `newVal + seqOpts.Increment`.
	SetSequenceValue(ctx context.Context, seqName *TableName, newVal int64, isCalled bool) error
}

SequenceOperators is used for various sql related functions that can be used from EvalContext.

type SequenceOption 

type SequenceOption struct {
	Name string

	IntVal *int64

	OptionalWord bool

	ColumnItemVal *ColumnItem
}

SequenceOption represents an option on a CREATE SEQUENCE statement.

type SequenceOptions 

type SequenceOptions []SequenceOption

SequenceOptions represents a list of sequence options.

func (*SequenceOptions) Format 

func (node *SequenceOptions) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type SetClusterSetting 

type SetClusterSetting struct {
	Name  string
	Value Expr
}

SetClusterSetting represents a SET CLUSTER SETTING statement.

func (*SetClusterSetting) Format 

func (node *SetClusterSetting) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*SetClusterSetting) StatementTag 

func (*SetClusterSetting) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*SetClusterSetting) StatementType 

func (*SetClusterSetting) StatementType() StatementType

StatementType implements the Statement interface.

func (*SetClusterSetting) String 

func (n *SetClusterSetting) String() string

type SetSessionAuthorizationDefault 

type SetSessionAuthorizationDefault struct{}

SetSessionAuthorizationDefault represents a SET SESSION AUTHORIZATION DEFAULT statement. This can be extended (and renamed) if we ever support names in the last position.

func (*SetSessionAuthorizationDefault) Format 

func (node *SetSessionAuthorizationDefault) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*SetSessionAuthorizationDefault) StatementTag 

func (*SetSessionAuthorizationDefault) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*SetSessionAuthorizationDefault) StatementType 

func (*SetSessionAuthorizationDefault) StatementType() StatementType

StatementType implements the Statement interface.

func (*SetSessionAuthorizationDefault) String 

func (n *SetSessionAuthorizationDefault) String() string

type SetSessionCharacteristics 

type SetSessionCharacteristics struct {
	Modes TransactionModes
}

SetSessionCharacteristics represents a SET SESSION CHARACTERISTICS AS TRANSACTION statement.

func (*SetSessionCharacteristics) Format 

func (node *SetSessionCharacteristics) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*SetSessionCharacteristics) StatementTag 

func (*SetSessionCharacteristics) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*SetSessionCharacteristics) StatementType 

func (*SetSessionCharacteristics) StatementType() StatementType

StatementType implements the Statement interface.

func (*SetSessionCharacteristics) String 

func (n *SetSessionCharacteristics) String() string

type SetTracing 

type SetTracing struct {
	Values Exprs
}

SetTracing represents a SET TRACING statement.

func (*SetTracing) Format 

func (node *SetTracing) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*SetTracing) StatementTag 

func (*SetTracing) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*SetTracing) StatementType 

func (*SetTracing) StatementType() StatementType

StatementType implements the Statement interface.

func (*SetTracing) String 

func (n *SetTracing) String() string

type SetTransaction 

type SetTransaction struct {
	Modes TransactionModes
}

SetTransaction represents a SET TRANSACTION statement.

func (*SetTransaction) Format 

func (node *SetTransaction) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*SetTransaction) StatementTag 

func (*SetTransaction) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*SetTransaction) StatementType 

func (*SetTransaction) StatementType() StatementType

StatementType implements the Statement interface.

func (*SetTransaction) String 

func (n *SetTransaction) String() string

type SetVar 

type SetVar struct {
	Name   string
	Values Exprs
}

SetVar represents a SET or RESET statement.

func (*SetVar) Format 

func (node *SetVar) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*SetVar) StatementTag 

func (*SetVar) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*SetVar) StatementType 

func (*SetVar) StatementType() StatementType

StatementType implements the Statement interface.

func (*SetVar) String 

func (n *SetVar) String() string

type SetZoneConfig 

type SetZoneConfig struct {
	ZoneSpecifier
	// AllIndexes indicates that the zone configuration should be applied across
	// all of a tables indexes. (ALTER PARTITION ... OF INDEX <tablename>@*)
	AllIndexes bool
	SetDefault bool
	YAMLConfig Expr
	Options    KVOptions
}

SetZoneConfig represents an ALTER DATABASE/TABLE... CONFIGURE ZONE statement.

func (*SetZoneConfig) Format 

func (node *SetZoneConfig) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*SetZoneConfig) StatementTag 

func (*SetZoneConfig) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*SetZoneConfig) StatementType 

func (*SetZoneConfig) StatementType() StatementType

StatementType implements the Statement interface.

func (*SetZoneConfig) String 

func (n *SetZoneConfig) String() string

type ShardedIndexDef 

type ShardedIndexDef struct {
	ShardBuckets Expr
}

ShardedIndexDef represents a hash sharded secondary index definition within a CREATE TABLE or CREATE INDEX statement.

func (*ShardedIndexDef) Format 

func (node *ShardedIndexDef) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type ShardedPrimaryKeyConstraint 

type ShardedPrimaryKeyConstraint struct {
	Sharded      bool
	ShardBuckets Expr
}

ShardedPrimaryKeyConstraint represents `PRIMARY KEY .. USING HASH..` on a column.

type ShowBackup 

type ShowBackup struct {
	Path                 Expr
	Details              BackupDetails
	ShouldIncludeSchemas bool
	Options              KVOptions
}

ShowBackup represents a SHOW BACKUP statement.

func (*ShowBackup) Format 

func (node *ShowBackup) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowBackup) StatementTag 

func (*ShowBackup) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowBackup) StatementType 

func (*ShowBackup) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowBackup) String 

func (n *ShowBackup) String() string

type ShowClusterSetting 

type ShowClusterSetting struct {
	Name string
}

ShowClusterSetting represents a SHOW CLUSTER SETTING statement.

func (*ShowClusterSetting) Format 

func (node *ShowClusterSetting) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowClusterSetting) StatementTag 

func (*ShowClusterSetting) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowClusterSetting) StatementType 

func (*ShowClusterSetting) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowClusterSetting) String 

func (n *ShowClusterSetting) String() string

type ShowClusterSettingList 

type ShowClusterSettingList struct {
	// All indicates whether to include non-public settings in the output.
	All bool
}

ShowClusterSettingList represents a SHOW [ALL|PUBLIC] CLUSTER SETTINGS statement.

func (*ShowClusterSettingList) Format 

func (node *ShowClusterSettingList) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowClusterSettingList) StatementTag 

func (*ShowClusterSettingList) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowClusterSettingList) StatementType 

func (*ShowClusterSettingList) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowClusterSettingList) String 

func (n *ShowClusterSettingList) String() string

type ShowColumns 

type ShowColumns struct {
	Table       *UnresolvedObjectName
	WithComment bool
}

ShowColumns represents a SHOW COLUMNS statement.

func (*ShowColumns) Format 

func (node *ShowColumns) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowColumns) StatementTag 

func (*ShowColumns) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowColumns) StatementType 

func (*ShowColumns) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowColumns) String 

func (n *ShowColumns) String() string

type ShowConstraints 

type ShowConstraints struct {
	Table *UnresolvedObjectName
}

ShowConstraints represents a SHOW CONSTRAINTS statement.

func (*ShowConstraints) Format 

func (node *ShowConstraints) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowConstraints) StatementTag 

func (*ShowConstraints) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowConstraints) StatementType 

func (*ShowConstraints) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowConstraints) String 

func (n *ShowConstraints) String() string

type ShowCreate 

type ShowCreate struct {
	Name *UnresolvedObjectName
}

ShowCreate represents a SHOW CREATE statement.

func (*ShowCreate) Format 

func (node *ShowCreate) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowCreate) StatementTag 

func (*ShowCreate) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowCreate) StatementType 

func (*ShowCreate) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowCreate) String 

func (n *ShowCreate) String() string

type ShowDatabaseIndexes 

type ShowDatabaseIndexes struct {
	Database    Name
	WithComment bool
}

ShowDatabaseIndexes represents a SHOW INDEXES FROM DATABASE statement.

func (*ShowDatabaseIndexes) Format 

func (node *ShowDatabaseIndexes) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowDatabaseIndexes) StatementTag 

func (*ShowDatabaseIndexes) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowDatabaseIndexes) StatementType 

func (*ShowDatabaseIndexes) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowDatabaseIndexes) String 

func (n *ShowDatabaseIndexes) String() string

type ShowDatabases 

type ShowDatabases struct {
	WithComment bool
}

ShowDatabases represents a SHOW DATABASES statement.

func (*ShowDatabases) Format 

func (node *ShowDatabases) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowDatabases) StatementTag 

func (*ShowDatabases) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowDatabases) StatementType 

func (*ShowDatabases) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowDatabases) String 

func (n *ShowDatabases) String() string

type ShowFingerprints 

type ShowFingerprints struct {
	Table *UnresolvedObjectName
}

ShowFingerprints represents a SHOW EXPERIMENTAL_FINGERPRINTS statement.

func (*ShowFingerprints) Format 

func (node *ShowFingerprints) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowFingerprints) StatementTag 

func (*ShowFingerprints) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowFingerprints) StatementType 

func (*ShowFingerprints) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowFingerprints) String 

func (n *ShowFingerprints) String() string

type ShowGrants 

type ShowGrants struct {
	Targets  *TargetList
	Grantees NameList
}

ShowGrants represents a SHOW GRANTS statement. TargetList is defined in grant.go.

func (*ShowGrants) Format 

func (node *ShowGrants) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowGrants) StatementTag 

func (*ShowGrants) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowGrants) StatementType 

func (*ShowGrants) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowGrants) String 

func (n *ShowGrants) String() string

type ShowHistogram 

type ShowHistogram struct {
	HistogramID int64
}

ShowHistogram represents a SHOW HISTOGRAM statement.

func (*ShowHistogram) Format 

func (node *ShowHistogram) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowHistogram) StatementTag 

func (*ShowHistogram) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowHistogram) StatementType 

func (*ShowHistogram) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowHistogram) String 

func (n *ShowHistogram) String() string

type ShowIndexes 

type ShowIndexes struct {
	Table       *UnresolvedObjectName
	WithComment bool
}

ShowIndexes represents a SHOW INDEX statement.

func (*ShowIndexes) Format 

func (node *ShowIndexes) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowIndexes) StatementTag 

func (*ShowIndexes) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowIndexes) StatementType 

func (*ShowIndexes) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowIndexes) String 

func (n *ShowIndexes) String() string

type ShowJobs 

type ShowJobs struct {
	// If non-nil, a select statement that provides the job ids to be shown.
	Jobs *Select

	// If Automatic is true, show only automatically-generated jobs such
	// as automatic CREATE STATISTICS jobs. If Automatic is false, show
	// only non-automatically-generated jobs.
	Automatic bool

	// Whether to block and wait for completion of all running jobs to be displayed.
	Block bool
}

ShowJobs represents a SHOW JOBS statement

func (*ShowJobs) Format 

func (node *ShowJobs) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowJobs) StatementTag 

func (*ShowJobs) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowJobs) StatementType 

func (*ShowJobs) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowJobs) String 

func (n *ShowJobs) String() string

type ShowLastQueryStatistics 

type ShowLastQueryStatistics struct{}

ShowLastQueryStatistics represents a SHOW LAST QUERY STATS statement.

func (*ShowLastQueryStatistics) Format 

func (node *ShowLastQueryStatistics) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowLastQueryStatistics) StatementTag 

func (*ShowLastQueryStatistics) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowLastQueryStatistics) StatementType 

func (*ShowLastQueryStatistics) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowLastQueryStatistics) String 

func (n *ShowLastQueryStatistics) String() string

type ShowPartitions 

type ShowPartitions struct {
	IsDB     bool
	Database Name

	IsIndex bool
	Index   TableIndexName

	IsTable bool
	Table   *UnresolvedObjectName
}

ShowPartitions represents a SHOW PARTITIONS statement.

func (*ShowPartitions) Format 

func (node *ShowPartitions) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowPartitions) StatementTag 

func (*ShowPartitions) StatementTag() string

StatementTag returns a short string identifying the type of the statement.

func (*ShowPartitions) StatementType 

func (*ShowPartitions) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowPartitions) String 

func (n *ShowPartitions) String() string

type ShowQueries 

type ShowQueries struct {
	All     bool
	Cluster bool
}

ShowQueries represents a SHOW QUERIES statement.

func (*ShowQueries) Format 

func (node *ShowQueries) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowQueries) StatementTag 

func (*ShowQueries) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowQueries) StatementType 

func (*ShowQueries) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowQueries) String 

func (n *ShowQueries) String() string

type ShowRangeForRow 

type ShowRangeForRow struct {
	TableOrIndex TableIndexName
	Row          Exprs
}

ShowRangeForRow represents a SHOW RANGE FOR ROW statement.

func (*ShowRangeForRow) Format 

func (node *ShowRangeForRow) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowRangeForRow) StatementTag 

func (*ShowRangeForRow) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowRangeForRow) StatementType 

func (*ShowRangeForRow) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowRangeForRow) String 

func (n *ShowRangeForRow) String() string

type ShowRanges 

type ShowRanges struct {
	TableOrIndex TableIndexName
	DatabaseName Name
}

ShowRanges represents a SHOW RANGES statement.

func (*ShowRanges) Format 

func (node *ShowRanges) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowRanges) StatementTag 

func (*ShowRanges) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowRanges) StatementType 

func (*ShowRanges) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowRanges) String 

func (n *ShowRanges) String() string

type ShowRoleGrants 

type ShowRoleGrants struct {
	Roles    NameList
	Grantees NameList
}

ShowRoleGrants represents a SHOW GRANTS ON ROLE statement.

func (*ShowRoleGrants) Format 

func (node *ShowRoleGrants) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowRoleGrants) StatementTag 

func (*ShowRoleGrants) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowRoleGrants) StatementType 

func (*ShowRoleGrants) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowRoleGrants) String 

func (n *ShowRoleGrants) String() string

type ShowRoles 

type ShowRoles struct {
}

ShowRoles represents a SHOW ROLES statement.

func (*ShowRoles) Format 

func (node *ShowRoles) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowRoles) StatementTag 

func (*ShowRoles) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowRoles) StatementType 

func (*ShowRoles) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowRoles) String 

func (n *ShowRoles) String() string

type ShowSavepointStatus 

type ShowSavepointStatus struct {
}

ShowSavepointStatus represents a SHOW SAVEPOINT STATUS statement.

func (*ShowSavepointStatus) Format 

func (node *ShowSavepointStatus) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowSavepointStatus) StatementTag 

func (*ShowSavepointStatus) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowSavepointStatus) StatementType 

func (*ShowSavepointStatus) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowSavepointStatus) String 

func (n *ShowSavepointStatus) String() string

type ShowSchemas 

type ShowSchemas struct {
	Database Name
}

ShowSchemas represents a SHOW SCHEMAS statement.

func (*ShowSchemas) Format 

func (node *ShowSchemas) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowSchemas) StatementTag 

func (*ShowSchemas) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowSchemas) StatementType 

func (*ShowSchemas) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowSchemas) String 

func (n *ShowSchemas) String() string

type ShowSequences 

type ShowSequences struct {
	Database Name
}

ShowSequences represents a SHOW SEQUENCES statement.

func (*ShowSequences) Format 

func (node *ShowSequences) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowSequences) StatementTag 

func (*ShowSequences) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowSequences) StatementType 

func (*ShowSequences) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowSequences) String 

func (n *ShowSequences) String() string

type ShowSessions 

type ShowSessions struct {
	All     bool
	Cluster bool
}

ShowSessions represents a SHOW SESSIONS statement

func (*ShowSessions) Format 

func (node *ShowSessions) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowSessions) StatementTag 

func (*ShowSessions) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowSessions) StatementType 

func (*ShowSessions) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowSessions) String 

func (n *ShowSessions) String() string

type ShowSyntax 

type ShowSyntax struct {
	Statement string
}

ShowSyntax represents a SHOW SYNTAX statement. This the most lightweight thing that can be done on a statement server-side: just report the statement that was entered without any processing. Meant for use for syntax checking on clients, when the client version might differ from the server.

func (*ShowSyntax) Format 

func (node *ShowSyntax) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowSyntax) StatementTag 

func (*ShowSyntax) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowSyntax) StatementType 

func (*ShowSyntax) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowSyntax) String 

func (n *ShowSyntax) String() string

type ShowTableStats 

type ShowTableStats struct {
	Table     *UnresolvedObjectName
	UsingJSON bool
}

ShowTableStats represents a SHOW STATISTICS FOR TABLE statement.

func (*ShowTableStats) Format 

func (node *ShowTableStats) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowTableStats) StatementTag 

func (*ShowTableStats) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowTableStats) StatementType 

func (*ShowTableStats) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowTableStats) String 

func (n *ShowTableStats) String() string

type ShowTables 

type ShowTables struct {
	ObjectNamePrefix
	WithComment bool
}

ShowTables represents a SHOW TABLES statement.

func (*ShowTables) Format 

func (node *ShowTables) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowTables) StatementTag 

func (*ShowTables) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowTables) StatementType 

func (*ShowTables) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowTables) String 

func (n *ShowTables) String() string

type ShowTraceForSession 

type ShowTraceForSession struct {
	TraceType ShowTraceType
	Compact   bool
}

ShowTraceForSession represents a SHOW TRACE FOR SESSION statement.

func (*ShowTraceForSession) Format 

func (node *ShowTraceForSession) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowTraceForSession) StatementTag 

func (*ShowTraceForSession) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowTraceForSession) StatementType 

func (*ShowTraceForSession) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowTraceForSession) String 

func (n *ShowTraceForSession) String() string

type ShowTraceType 

type ShowTraceType string

ShowTraceType is an enum of SHOW TRACE variants. 

const (
	ShowTraceRaw     ShowTraceType = "TRACE"
	ShowTraceKV      ShowTraceType = "KV TRACE"
	ShowTraceReplica ShowTraceType = "EXPERIMENTAL_REPLICA TRACE"
)

A list of the SHOW TRACE variants.

type ShowTransactionStatus 

type ShowTransactionStatus struct {
}

ShowTransactionStatus represents a SHOW TRANSACTION STATUS statement.

func (*ShowTransactionStatus) Format 

func (node *ShowTransactionStatus) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowTransactionStatus) StatementTag 

func (*ShowTransactionStatus) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowTransactionStatus) StatementType 

func (*ShowTransactionStatus) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowTransactionStatus) String 

func (n *ShowTransactionStatus) String() string

type ShowUsers 

type ShowUsers struct {
}

ShowUsers represents a SHOW USERS statement.

func (*ShowUsers) Format 

func (node *ShowUsers) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowUsers) StatementTag 

func (*ShowUsers) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowUsers) StatementType 

func (*ShowUsers) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowUsers) String 

func (n *ShowUsers) String() string

type ShowVar 

type ShowVar struct {
	Name string
}

ShowVar represents a SHOW statement.

func (*ShowVar) Format 

func (node *ShowVar) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowVar) StatementTag 

func (*ShowVar) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowVar) StatementType 

func (*ShowVar) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowVar) String 

func (n *ShowVar) String() string

type ShowZoneConfig 

type ShowZoneConfig struct {
	ZoneSpecifier
}

ShowZoneConfig represents a SHOW ZONE CONFIGURATION statement.

func (*ShowZoneConfig) Format 

func (node *ShowZoneConfig) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ShowZoneConfig) StatementTag 

func (*ShowZoneConfig) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ShowZoneConfig) StatementType 

func (*ShowZoneConfig) StatementType() StatementType

StatementType implements the Statement interface.

func (*ShowZoneConfig) String 

func (n *ShowZoneConfig) String() string

type SimpleVisitFn 

type SimpleVisitFn func(expr Expr) (recurse bool, newExpr Expr, err error)

SimpleVisitFn is a function that is run for every node in the VisitPre stage; see SimpleVisit.

type SpecializedVectorizedBuiltin 

type SpecializedVectorizedBuiltin int

SpecializedVectorizedBuiltin is used to map overloads to the vectorized operator that is specific to that implementation of the builtin function. 

const (
	SubstringStringIntInt SpecializedVectorizedBuiltin
)

Keep this list alphabetized so that it is easy to manage.

type Split 

type Split struct {
	TableOrIndex TableIndexName
	// Each row contains values for the columns in the PK or index (or a prefix
	// of the columns).
	Rows *Select
	// Splits can last a specified amount of time before becoming eligible for
	// automatic merging.
	ExpireExpr Expr
}

Split represents an `ALTER TABLE/INDEX .. SPLIT AT ..` statement.

func (*Split) Format 

func (node *Split) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Split) StatementTag 

func (*Split) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Split) StatementType 

func (*Split) StatementType() StatementType

StatementType implements the Statement interface.

func (*Split) String 

func (n *Split) String() string

type Statement 

type Statement interface {
	fmt.Stringer
	NodeFormatter
	StatementType() StatementType
	// StatementTag is a short string identifying the type of statement
	// (usually a single verb). This is different than the Stringer output,
	// which is the actual statement (including args).
	// TODO(dt): Currently tags are always pg-compatible in the future it
	// might make sense to pass a tag format specifier.
	StatementTag() string
}

Statement represents a statement.

func MakeExplain 

func MakeExplain(options []string, stmt Statement) (Statement, error)

MakeExplain parses the EXPLAIN option strings and generates an explain statement.

type StatementSource 

type StatementSource struct {
	Statement Statement
}

StatementSource encapsulates one of the other statements as a data source.

func (*StatementSource) Format 

func (node *StatementSource) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type StatementType 

type StatementType int

StatementType is the enumerated type for Statement return styles on the wire. 

const (
	// Ack indicates that the statement does not have a meaningful
	// return. Examples include SET, BEGIN, COMMIT.
	Ack StatementType = iota
	// DDL indicates that the statement mutates the database schema.
	//
	// Note: this is the type indicated back to the client; it is not a
	// sufficient test for schema mutation for planning purposes. There
	// are schema-modifying statements (e.g. CREATE TABLE AS) which
	// report RowsAffected to the client, not DDL.
	// Use CanModifySchema() below instead.
	DDL
	// RowsAffected indicates that the statement returns the count of
	// affected rows.
	RowsAffected
	// Rows indicates that the statement returns the affected rows after
	// the statement was applied.
	Rows
	// CopyIn indicates a COPY FROM statement.
	CopyIn
	// Unknown indicates that the statement does not have a known
	// return style at the time of parsing. This is not first in the
	// enumeration because it is more convenient to have Ack as a zero
	// value, and because the use of Unknown should be an explicit choice.
	// The primary example of this statement type is EXECUTE, where the
	// statement type depends on the statement type of the prepared statement
	// being executed.
	Unknown
)

func (StatementType) String 

func (i StatementType) String() string

type StorageParam 

type StorageParam struct {
	Key   Name
	Value Expr
}

StorageParam is a key-value parameter for table storage.

type StorageParams 

type StorageParams []StorageParam

StorageParams is a list of StorageParams.

func (*StorageParams) Format 

func (o *StorageParams) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type StrVal 

type StrVal struct {
	// contains filtered or unexported fields
}

StrVal represents a constant string value.

func NewBytesStrVal 

func NewBytesStrVal(s string) *StrVal

NewBytesStrVal constructs a StrVal instance suitable as byte array. This is used during parsing when interpreting a token of type BCONST, i.e. using the b'...' or x'...' syntax.

func NewStrVal 

func NewStrVal(s string) *StrVal

NewStrVal constructs a StrVal instance. This is used during parsing when interpreting a token of type SCONST, i.e. *not* using the b'...' or x'...' syntax.

func (*StrVal) AvailableTypes 

func (expr *StrVal) AvailableTypes() []*types.T

AvailableTypes implements the Constant interface.

To fully take advantage of literal type inference, this method would determine exactly which types are available for a given string. This would entail attempting to parse the literal string as a date, a timestamp, an interval, etc. and having more fine-grained results than StrValAvailAllParsable. However, this is not feasible in practice because of the associated parsing overhead.

Conservative approaches like checking the string's length have been investigated to reduce ambiguity and improve type inference in some cases. When doing so, the length of the string literal was compared against all valid date and timestamp formats to quickly gain limited insight into whether parsing the string as the respective datum types could succeed. The hope was to eliminate impossibilities and constrain the returned type sets as much as possible. Unfortunately, two issues were found with this approach:

  • date and timestamp formats do not always imply a fixed-length valid input. For instance, timestamp formats that take fractional seconds can successfully parse inputs of varied length.
  • the set of date and timestamp formats are not disjoint, which means that ambiguity can not be eliminated when inferring the type of string literals that use these shared formats.

While these limitations still permitted improved type inference in many cases, they resulted in behavior that was ultimately incomplete, resulted in unpredictable levels of inference, and occasionally failed to eliminate ambiguity. Further heuristics could have been applied to improve the accuracy of the inference, like checking that all or some characters were digits, but it would not have circumvented the fundamental issues here. Fully parsing the literal into each type would be the only way to concretely avoid the issue of unpredictable inference behavior.

func (*StrVal) DesirableTypes 

func (expr *StrVal) DesirableTypes() []*types.T

DesirableTypes implements the Constant interface.

func (*StrVal) Format 

func (expr *StrVal) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*StrVal) RawString 

func (expr *StrVal) RawString() string

RawString retrieves the underlying string of the StrVal.

func (*StrVal) ResolveAsType 

func (expr *StrVal) ResolveAsType(
	ctx context.Context, semaCtx *SemaContext, typ *types.T,
) (TypedExpr, error)

ResolveAsType implements the Constant interface.

func (*StrVal) String 

func (node *StrVal) String() string

func (*StrVal) TypeCheck 

func (expr *StrVal) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*StrVal) Walk 

func (expr *StrVal) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type Subquery 

type Subquery struct {
	Select SelectStatement
	Exists bool

	// Idx is a query-unique index for the subquery.
	// Subqueries are 1-indexed to ensure that the default
	// value 0 can be used to detect uninitialized subqueries.
	Idx int
	// contains filtered or unexported fields
}

Subquery represents a subquery.

func (*Subquery) Eval 

func (expr *Subquery) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*Subquery) Format 

func (node *Subquery) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (Subquery) ResolvedType 

func (ta Subquery) ResolvedType() *types.T

func (*Subquery) SetType 

func (node *Subquery) SetType(t *types.T)

SetType forces the type annotation on the Subquery node.

func (*Subquery) String 

func (node *Subquery) String() string

func (*Subquery) SubqueryExpr 

func (*Subquery) SubqueryExpr()

SubqueryExpr implements the SubqueryExpr interface.

func (*Subquery) TypeCheck 

func (expr *Subquery) TypeCheck(_ context.Context, sc *SemaContext, _ *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*Subquery) Variable 

func (*Subquery) Variable()

Variable implements the VariableExpr interface.

func (*Subquery) Walk 

func (expr *Subquery) Walk(v Visitor) Expr

Walk implements the Expr interface.

type SubqueryExpr 

type SubqueryExpr interface {
	Expr
	SubqueryExpr()
}

SubqueryExpr is an interface used to identify an expression as a subquery. It is implemented by both ast.Subquery and optbuilder.subquery, and is used in TypeCheck.

type TableDef 

type TableDef interface {
	NodeFormatter
	// contains filtered or unexported methods
}

TableDef represents a column, index or constraint definition within a CREATE TABLE statement.

type TableDefs 

type TableDefs []TableDef

TableDefs represents a list of table definitions.

func (*TableDefs) Format 

func (node *TableDefs) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type TableExpr 

type TableExpr interface {
	NodeFormatter
	// contains filtered or unexported methods
}

TableExpr represents a table expression.

func StripTableParens 

func StripTableParens(expr TableExpr) TableExpr

StripTableParens strips any parentheses surrounding a selection clause.

type TableExprs 

type TableExprs []TableExpr

TableExprs represents a list of table expressions.

func (*TableExprs) Format 

func (node *TableExprs) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type TableIndexName 

type TableIndexName struct {
	Table TableName
	Index UnrestrictedName
}

TableIndexName refers to a table index. There are a few cases:

  • if both the table name and the index name are set, refers to a specific index in a specific table.

  • if the table name is set and index name is empty, refers to the primary index of that table.

  • if the table name is empty and the index name is set, refers to an index of that name among all tables within a catalog/schema; if there is a duplicate name, that will result in an error. Note that it is possible to specify the schema or catalog without specifying a table name; in this case, Table.ObjectNamePrefix has the fields set but Table.ObjectName is empty.

func (*TableIndexName) Format 

func (n *TableIndexName) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*TableIndexName) String 

func (n *TableIndexName) String() string

type TableIndexNames 

type TableIndexNames []*TableIndexName

TableIndexNames is a list of indexes.

func (*TableIndexNames) Format 

func (n *TableIndexNames) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type TableName 

type TableName struct {
	// contains filtered or unexported fields
}

TableName corresponds to the name of a table in a FROM clause, INSERT or UPDATE statement, etc.

This is constructed for incoming SQL queries from an UnresolvedObjectName,

Internal uses of this struct should not construct instances of TableName directly, and instead use the NewTableName / MakeTableName functions underneath.

TableName is a public type for objName. It exposes the fields and can be default-constructed but cannot be instantiated with a non-default value; this encourages the use of the constructors below.

func MakeTableName 

func MakeTableName(db, tbl Name) TableName

MakeTableName creates a new table name qualified with just a schema.

func MakeTableNameFromPrefix 

func MakeTableNameFromPrefix(prefix ObjectNamePrefix, object Name) TableName

MakeTableNameFromPrefix creates a table name from an unqualified name and a resolved prefix.

func MakeTableNameWithSchema 

func MakeTableNameWithSchema(db, schema, tbl Name) TableName

MakeTableNameWithSchema creates a new fully qualified table name.

func MakeUnqualifiedTableName 

func MakeUnqualifiedTableName(tbl Name) TableName

MakeUnqualifiedTableName creates a new base table name.

func NewTableName 

func NewTableName(db, tbl Name) *TableName

NewTableName creates a new table name qualified with a given catalog and the public schema.

func NewUnqualifiedTableName 

func NewUnqualifiedTableName(tbl Name) *TableName

NewUnqualifiedTableName creates a new base table name.

func (*TableName) Equals 

func (t *TableName) Equals(other *TableName) bool

Equals returns true if the two table names are identical (including the ExplicitSchema/ExplicitCatalog flags).

func (*TableName) FQString 

func (t *TableName) FQString() string

FQString renders the table name in full, not omitting the prefix schema and catalog names. Suitable for logging, etc.

func (*TableName) Format 

func (t *TableName) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*TableName) NormalizeTablePattern 

func (t *TableName) NormalizeTablePattern() (TablePattern, error)

NormalizeTablePattern implements the TablePattern interface.

func (*TableName) Object 

func (o *TableName) Object() string

func (*TableName) String 

func (t *TableName) String() string

func (*TableName) Table 

func (t *TableName) Table() string

Table retrieves the unqualified table name.

func (*TableName) ToUnresolvedObjectName 

func (o *TableName) ToUnresolvedObjectName() *UnresolvedObjectName

ToUnresolvedObjectName converts the type name to an unresolved object name. Schema and catalog are included if indicated by the ExplicitSchema and ExplicitCatalog flags.

type TableNames 

type TableNames []TableName

TableNames represents a comma separated list (see the Format method) of table names.

func (*TableNames) Format 

func (ts *TableNames) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*TableNames) String 

func (ts *TableNames) String() string

type TablePattern 

type TablePattern interface {
	fmt.Stringer
	NodeFormatter

	// NormalizeTablePattern() guarantees to return a pattern that is
	// not an UnresolvedName. This converts the UnresolvedName to an
	// AllTablesSelector or TableName as necessary.
	NormalizeTablePattern() (TablePattern, error)
}

TablePattern is the common interface to UnresolvedName, TableName and AllTablesSelector.

type TablePatterns 

type TablePatterns []TablePattern

TablePatterns implement a comma-separated list of table patterns. Used by e.g. the GRANT statement.

func (*TablePatterns) Format 

func (tt *TablePatterns) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type TableRef 

type TableRef struct {
	// TableID is the descriptor ID of the requested table.
	TableID int64

	// ColumnIDs is the list of column IDs requested in the table.
	// Note that a nil array here means "unspecified" (all columns)
	// whereas an array of length 0 means "zero columns".
	// Lists of zero columns are not supported and will throw an error.
	Columns []ColumnID

	// As determines the names that can be used in the surrounding query
	// to refer to this source.
	As AliasClause
}

TableRef represents a numeric table reference. (Syntax !NNN in SQL.)

func (*TableRef) Format 

func (n *TableRef) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*TableRef) String 

func (n *TableRef) String() string

type TargetList 

type TargetList struct {
	Databases NameList
	Tables    TablePatterns
	Tenant    roachpb.TenantID

	// ForRoles and Roles are used internally in the parser and not used
	// in the AST. Therefore they do not participate in pretty-printing,
	// etc.
	ForRoles bool
	Roles    NameList
}

TargetList represents a list of targets. Only one field may be non-nil.

func (*TargetList) Format 

func (tl *TargetList) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type TenantOperator 

type TenantOperator interface {
	// CreateTenant attempts to install a new tenant in the system. It returns
	// an error if the tenant already exists.
	CreateTenant(ctx context.Context, tenantID uint64, tenantInfo []byte) error

	// DestroyTenant attempts to uninstall an existing tenant from the system.
	// It returns an error if the tenant does not exist.
	DestroyTenant(ctx context.Context, tenantID uint64) error
}

TenantOperator is capable of interacting with tenant state, allowing SQL builtin functions to create and destroy tenants. The methods will return errors when run by any tenant other than the system tenant.

type TestingMapTypeResolver 

type TestingMapTypeResolver struct {
	// contains filtered or unexported fields
}

TestingMapTypeResolver is a fake type resolver for testing purposes.

func (*TestingMapTypeResolver) ResolveType 

func (dtr *TestingMapTypeResolver) ResolveType(
	_ context.Context, name *UnresolvedObjectName,
) (*types.T, error)

ResolveType implements the TypeReferenceResolver interface.

func (*TestingMapTypeResolver) ResolveTypeByID 

func (dtr *TestingMapTypeResolver) ResolveTypeByID(context.Context, uint32) (*types.T, error)

ResolveTypeByID implements the TypeReferenceResolver interface.

type TransactionModes 

type TransactionModes struct {
	Isolation     IsolationLevel
	UserPriority  UserPriority
	ReadWriteMode ReadWriteMode
	AsOf          AsOfClause
}

TransactionModes holds the transaction modes for a transaction.

func (*TransactionModes) Format 

func (node *TransactionModes) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*TransactionModes) Merge 

func (node *TransactionModes) Merge(other TransactionModes) error

Merge groups two sets of transaction modes together. Used in the parser.

type Truncate 

type Truncate struct {
	Tables       TableNames
	DropBehavior DropBehavior
}

Truncate represents a TRUNCATE statement.

func (*Truncate) Format 

func (node *Truncate) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Truncate) StatementTag 

func (*Truncate) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Truncate) StatementType 

func (*Truncate) StatementType() StatementType

StatementType implements the Statement interface.

func (*Truncate) String 

func (n *Truncate) String() string

type Tuple 

type Tuple struct {
	Exprs  Exprs
	Labels []string

	// Row indicates whether `ROW` was used in the input syntax. This is
	// used solely to generate column names automatically, see
	// col_name.go.
	Row bool
	// contains filtered or unexported fields
}

Tuple represents a parenthesized list of expressions.

func NewTypedTuple 

func NewTypedTuple(typ *types.T, typedExprs Exprs) *Tuple

NewTypedTuple returns a new Tuple that is verified to be well-typed.

func (*Tuple) Eval 

func (t *Tuple) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*Tuple) Format 

func (node *Tuple) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Tuple) ResolvedType 

func (node *Tuple) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*Tuple) String 

func (node *Tuple) String() string

func (*Tuple) TypeCheck 

func (expr *Tuple) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*Tuple) Walk 

func (expr *Tuple) Walk(v Visitor) Expr

Walk implements the Expr interface.

type TupleStar 

type TupleStar struct {
	Expr Expr
}

TupleStar represents (E).* expressions. It is meant to evaporate during star expansion.

func (*TupleStar) Eval 

func (expr *TupleStar) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*TupleStar) Format 

func (node *TupleStar) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*TupleStar) NormalizeVarName 

func (node *TupleStar) NormalizeVarName() (VarName, error)

NormalizeVarName implements the VarName interface.

func (*TupleStar) ResolvedType 

func (expr *TupleStar) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*TupleStar) String 

func (node *TupleStar) String() string

func (*TupleStar) TypeCheck 

func (expr *TupleStar) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*TupleStar) Walk 

func (expr *TupleStar) Walk(v Visitor) Expr

Walk implements the Expr interface.

type TypeCollectorVisitor 

type TypeCollectorVisitor struct {
	IDs map[uint32]struct{}
}

TypeCollectorVisitor is an expression visitor that collects all explicit ID type references in an expression.

func (*TypeCollectorVisitor) VisitPost 

func (v *TypeCollectorVisitor) VisitPost(e Expr) Expr

VisitPost implements the Visitor interface.

func (*TypeCollectorVisitor) VisitPre 

func (v *TypeCollectorVisitor) VisitPre(expr Expr) (bool, Expr)

VisitPre implements the Visitor interface.

type TypeList 

type TypeList interface {
	// Match checks if all types in the TypeList match the corresponding elements in types.
	Match(types []*types.T) bool
	// MatchAt checks if the parameter type at index i of the TypeList matches type typ.
	// In all implementations, types.Null will match with each parameter type, allowing
	// NULL values to be used as arguments.
	MatchAt(typ *types.T, i int) bool
	// matchLen checks that the TypeList can support l parameters.
	MatchLen(l int) bool
	// getAt returns the type at the given index in the TypeList, or nil if the TypeList
	// cannot have a parameter at index i.
	GetAt(i int) *types.T
	// Length returns the number of types in the list
	Length() int
	// Types returns a realized copy of the list. variadic lists return a list of size one.
	Types() []*types.T
	// String returns a human readable signature
	String() string
}

TypeList is a list of types representing a function parameter list.

type TypeName 

type TypeName struct {
	// contains filtered or unexported fields
}

TypeName corresponds to the name of a type in a CREATE TYPE statement, in an expression, or column type etc.

Users of this struct should not construct it directly, and instead use the constructors below.

func MakeNewQualifiedTypeName 

func MakeNewQualifiedTypeName(db, schema, typ string) TypeName

MakeNewQualifiedTypeName creates a fully qualified type name.

func MakeTypeNameFromPrefix 

func MakeTypeNameFromPrefix(prefix ObjectNamePrefix, object Name) TypeName

MakeTypeNameFromPrefix creates a type name from an unqualified name and a resolved prefix.

func NewUnqualifiedTypeName 

func NewUnqualifiedTypeName(typ Name) *TypeName

NewUnqualifiedTypeName returns a new base type name.

func (*TypeName) FQString 

func (t *TypeName) FQString() string

FQString renders the type name in full, not omitting the prefix schema and catalog names. Suitable for logging, etc.

func (*TypeName) Format 

func (t *TypeName) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*TypeName) Object 

func (o *TypeName) Object() string

func (*TypeName) String 

func (t *TypeName) String() string

String implements the Stringer interface.

func (*TypeName) ToUnresolvedObjectName 

func (o *TypeName) ToUnresolvedObjectName() *UnresolvedObjectName

ToUnresolvedObjectName converts the type name to an unresolved object name. Schema and catalog are included if indicated by the ExplicitSchema and ExplicitCatalog flags.

func (*TypeName) Type 

func (t *TypeName) Type() string

Type returns the unqualified name of this TypeName.

type TypeReferenceResolver 

type TypeReferenceResolver interface {
	ResolveType(ctx context.Context, name *UnresolvedObjectName) (*types.T, error)
	ResolveTypeByID(ctx context.Context, id uint32) (*types.T, error)
}

TypeReferenceResolver is the interface that will provide the ability to actually look up type metadata and transform references into *types.T's.

func MakeTestingMapTypeResolver 

func MakeTestingMapTypeResolver(typeMap map[string]*types.T) TypeReferenceResolver

MakeTestingMapTypeResolver creates a TestingMapTypeResolver from a map.

type TypedDummy 

type TypedDummy struct {
	Typ *types.T
}

TypedDummy is a dummy expression that represents a dummy value with a specified type. It can be used in situations where TypedExprs of a particular type are required for semantic analysis.

func (*TypedDummy) Eval 

func (node *TypedDummy) Eval(*EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*TypedDummy) Format 

func (node *TypedDummy) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*TypedDummy) ResolvedType 

func (node *TypedDummy) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*TypedDummy) String 

func (node *TypedDummy) String() string

func (*TypedDummy) TypeCheck 

func (node *TypedDummy) TypeCheck(context.Context, *SemaContext, *types.T) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*TypedDummy) Walk 

func (node *TypedDummy) Walk(Visitor) Expr

Walk implements the Expr interface.

type TypedExpr 

type TypedExpr interface {
	Expr
	// Eval evaluates an SQL expression. Expression evaluation is a
	// mostly straightforward walk over the parse ast. The only
	// significant complexity is the handling of types and implicit
	// conversions. See binOps and cmpOps for more details. Note that
	// expression evaluation returns an error if certain node types are
	// encountered: Placeholder, VarName (and related UnqualifiedStar,
	// UnresolvedName and AllColumnsSelector) or Subquery. These nodes
	// should be replaced prior to expression evaluation by an
	// appropriate WalkExpr. For example, Placeholder should be replace
	// by the argument passed from the client.
	Eval(*EvalContext) (Datum, error)
	// ResolvedType provides the type of the TypedExpr, which is the type of Datum
	// that the TypedExpr will return when evaluated.
	ResolvedType() *types.T
}

TypedExpr represents a well-typed expression.

func ReType 

func ReType(expr TypedExpr, wantedType *types.T) TypedExpr

ReType ensures that the given numeric expression evaluates to the requested type, inserting a cast if necessary.

func TypeCheck 

func TypeCheck(
	ctx context.Context, expr Expr, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck performs type checking on the provided expression tree, returning the new typed expression tree, which additionally permits evaluation and type introspection globally and on each sub-ast.

While doing so, it will fold numeric constants and bind placeholder names to their inferred types in the provided context. The optional desired parameter can be used to hint the desired type for the root of the resulting typed expression ast. Like with Expr.TypeCheck, it is not valid to provide a nil desired type. Instead, call it with the wildcard type types.Any if no specific type is desired.

func TypeCheckAndRequire 

func TypeCheckAndRequire(
	ctx context.Context, expr Expr, semaCtx *SemaContext, required *types.T, op string,
) (TypedExpr, error)

TypeCheckAndRequire performs type checking on the provided expression tree in an identical manner to TypeCheck. It then asserts that the resulting TypedExpr has the provided return type, returning both the typed expression and an error if it does not.

func TypeCheckSameTypedExprs 

func TypeCheckSameTypedExprs(
	ctx context.Context, semaCtx *SemaContext, desired *types.T, exprs ...Expr,
) ([]TypedExpr, *types.T, error)

TypeCheckSameTypedExprs type checks a list of expressions, asserting that all resolved TypeExprs have the same type. An optional desired type can be provided, which will hint that type which the expressions should resolve to, if possible.

type TypedExprs 

type TypedExprs []TypedExpr

TypedExprs represents a list of well-typed value expressions. It's not a valid expression because it's not parenthesized.

func (*TypedExprs) String 

func (node *TypedExprs) String() string

type UnaryExpr 

type UnaryExpr struct {
	Operator UnaryOperator
	Expr     Expr
	// contains filtered or unexported fields
}

UnaryExpr represents a unary value expression.

func NewTypedUnaryExpr 

func NewTypedUnaryExpr(op UnaryOperator, expr TypedExpr, typ *types.T) *UnaryExpr

NewTypedUnaryExpr returns a new UnaryExpr that is well-typed.

func (*UnaryExpr) Eval 

func (expr *UnaryExpr) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*UnaryExpr) Format 

func (node *UnaryExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (UnaryExpr) ResolvedType 

func (ta UnaryExpr) ResolvedType() *types.T

func (*UnaryExpr) String 

func (node *UnaryExpr) String() string

func (*UnaryExpr) TypeCheck 

func (expr *UnaryExpr) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*UnaryExpr) TypedInnerExpr 

func (node *UnaryExpr) TypedInnerExpr() TypedExpr

TypedInnerExpr returns the UnaryExpr's inner expression as a TypedExpr.

func (*UnaryExpr) Walk 

func (expr *UnaryExpr) Walk(v Visitor) Expr

Walk implements the Expr interface.

type UnaryOp 

type UnaryOp struct {
	Typ        *types.T
	ReturnType *types.T
	Fn         func(*EvalContext, Datum) (Datum, error)
	Volatility Volatility
	// contains filtered or unexported fields
}

UnaryOp is a unary operator.

type UnaryOperator 

type UnaryOperator int

UnaryOperator represents a unary operator. 

const (
	UnaryMinus UnaryOperator = iota
	UnaryComplement
	UnarySqrt
	UnaryCbrt

	NumUnaryOperators
)

UnaryExpr.Operator

func (UnaryOperator) String 

func (i UnaryOperator) String() string

type UnionClause 

type UnionClause struct {
	Type        UnionType
	Left, Right *Select
	All         bool
}

UnionClause represents a UNION statement.

func (*UnionClause) Format 

func (node *UnionClause) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*UnionClause) StatementTag 

func (*UnionClause) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*UnionClause) StatementType 

func (*UnionClause) StatementType() StatementType

StatementType implements the Statement interface.

func (*UnionClause) String 

func (n *UnionClause) String() string

type UnionType 

type UnionType int

UnionType represents one of the three set operations in sql. 

const (
	UnionOp UnionType = iota
	IntersectOp
	ExceptOp
)

Union.Type

func (UnionType) String 

func (i UnionType) String() string

type UniqueConstraint 

type UniqueConstraint struct{}

UniqueConstraint represents UNIQUE on a column.

type UniqueConstraintTableDef 

type UniqueConstraintTableDef struct {
	IndexTableDef
	PrimaryKey bool
}

UniqueConstraintTableDef represents a unique constraint within a CREATE TABLE statement.

func (*UniqueConstraintTableDef) Format 

func (node *UniqueConstraintTableDef) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*UniqueConstraintTableDef) SetName 

func (node *UniqueConstraintTableDef) SetName(name Name)

SetName implements the TableDef interface.

type UnqualifiedStar 

type UnqualifiedStar struct{}

UnqualifiedStar corresponds to a standalone '*' in a scalar expression.

func (UnqualifiedStar) Eval 

func (expr UnqualifiedStar) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (UnqualifiedStar) Format 

func (UnqualifiedStar) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (UnqualifiedStar) NormalizeVarName 

func (u UnqualifiedStar) NormalizeVarName() (VarName, error)

NormalizeVarName implements the VarName interface.

func (UnqualifiedStar) ResolvedType 

func (UnqualifiedStar) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (UnqualifiedStar) String 

func (u UnqualifiedStar) String() string

func (UnqualifiedStar) TypeCheck 

func (expr UnqualifiedStar) TypeCheck(
	_ context.Context, _ *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (UnqualifiedStar) Variable 

func (UnqualifiedStar) Variable()

Variable implements the VariableExpr interface.

func (UnqualifiedStar) Walk 

func (expr UnqualifiedStar) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type UnresolvedName 

type UnresolvedName struct {
	// NumParts indicates the number of name parts specified, including
	// the star. Always 1 or greater.
	NumParts int

	// Star indicates the name ends with a star.
	// In that case, Parts below is empty in the first position.
	Star bool

	// Parts are the name components, in reverse order.
	// There are at most 4: column, table, schema, catalog/db.
	//
	// Note: NameParts has a fixed size so that we avoid a heap
	// allocation for the slice every time we construct an
	// UnresolvedName. It does imply however that Parts does not have
	// a meaningful "length"; its actual length (the number of parts
	// specified) is populated in NumParts above.
	Parts NameParts
}

UnresolvedName corresponds to an unresolved qualified name.

func MakeUnresolvedName 

func MakeUnresolvedName(args ...string) UnresolvedName

MakeUnresolvedName constructs an UnresolvedName from some strings.

func NewUnresolvedName 

func NewUnresolvedName(args ...string) *UnresolvedName

NewUnresolvedName constructs an UnresolvedName from some strings.

func (*UnresolvedName) Eval 

func (expr *UnresolvedName) Eval(ctx *EvalContext) (Datum, error)

Eval implements the TypedExpr interface.

func (*UnresolvedName) Format 

func (u *UnresolvedName) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*UnresolvedName) NormalizeTablePattern 

func (n *UnresolvedName) NormalizeTablePattern() (TablePattern, error)

NormalizeTablePattern resolves an UnresolvedName to either a TableName or AllTablesSelector.

func (*UnresolvedName) NormalizeVarName 

func (n *UnresolvedName) NormalizeVarName() (VarName, error)

NormalizeVarName implements the VarName interface.

func (*UnresolvedName) ResolveFunction 

func (n *UnresolvedName) ResolveFunction(
	searchPath sessiondata.SearchPath,
) (*FunctionDefinition, error)

ResolveFunction transforms an UnresolvedName to a FunctionDefinition.

Function resolution currently takes a "short path" using the assumption that there are no stored functions in the database. That is, only functions in the (virtual) global namespace and virtual schemas can be used. This in turn implies that the current database does not matter and no resolver is needed.

TODO(whoever): this needs to be revisited when there can be stored functions. When that is the case, function names must be first normalized to e.g. TableName (or whatever an object name will be called by then) and then undergo regular name resolution via ResolveExisting(). When that happens, the following function can be removed.

func (*UnresolvedName) ResolvedType 

func (*UnresolvedName) ResolvedType() *types.T

ResolvedType implements the TypedExpr interface.

func (*UnresolvedName) String 

func (u *UnresolvedName) String() string

func (*UnresolvedName) ToUnresolvedObjectName 

func (u *UnresolvedName) ToUnresolvedObjectName(idx AnnotationIdx) (*UnresolvedObjectName, error)

ToUnresolvedObjectName converts an UnresolvedName to an UnresolvedObjectName.

func (*UnresolvedName) TypeCheck 

func (expr *UnresolvedName) TypeCheck(
	ctx context.Context, semaCtx *SemaContext, desired *types.T,
) (TypedExpr, error)

TypeCheck implements the Expr interface.

func (*UnresolvedName) Variable 

func (*UnresolvedName) Variable()

Variable implements the VariableExpr interface. Although, the UnresolvedName ought to be replaced to an IndexedVar before the points the VariableExpr interface is used.

func (*UnresolvedName) Walk 

func (expr *UnresolvedName) Walk(_ Visitor) Expr

Walk implements the Expr interface.

type UnresolvedObjectName 

type UnresolvedObjectName struct {
	// NumParts indicates the number of name parts specified; always 1 or greater.
	NumParts int

	// Parts are the name components, in reverse order.
	// There are at most 3: object name, schema, catalog/db.
	//
	// Note: Parts has a fixed size so that we avoid a heap allocation for the
	// slice every time we construct an UnresolvedObjectName. It does imply
	// however that Parts does not have a meaningful "length"; its actual length
	// (the number of parts specified) is populated in NumParts above.
	Parts [3]string

	// UnresolvedObjectName can be annotated with a *TableName.
	AnnotatedNode
}

UnresolvedObjectName is an unresolved qualified name for a database object (table, view, etc). It is like UnresolvedName but more restrictive. It should only be constructed via NewUnresolvedObjectName.

func NewUnresolvedObjectName 

func NewUnresolvedObjectName(
	numParts int, parts [3]string, annotationIdx AnnotationIdx,
) (*UnresolvedObjectName, error)

NewUnresolvedObjectName creates an unresolved object name, verifying that it is well-formed.

func (*UnresolvedObjectName) Catalog 

func (u *UnresolvedObjectName) Catalog() string

Catalog returns the catalog of the object.

func (*UnresolvedObjectName) Format 

func (u *UnresolvedObjectName) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*UnresolvedObjectName) HasExplicitCatalog 

func (u *UnresolvedObjectName) HasExplicitCatalog() bool

HasExplicitCatalog returns whether a catalog is specified on the object.

func (*UnresolvedObjectName) HasExplicitSchema 

func (u *UnresolvedObjectName) HasExplicitSchema() bool

HasExplicitSchema returns whether a schema is specified on the object.

func (*UnresolvedObjectName) Object 

func (u *UnresolvedObjectName) Object() string

Object returns the unqualified object name.

func (*UnresolvedObjectName) Resolved 

func (u *UnresolvedObjectName) Resolved(ann *Annotations) ObjectName

Resolved returns the resolved name in the annotation for this node (or nil if there isn't one).

func (*UnresolvedObjectName) SQLString 

func (name *UnresolvedObjectName) SQLString() string

SQLString implements the ResolvableTypeReference interface.

func (*UnresolvedObjectName) Schema 

func (u *UnresolvedObjectName) Schema() string

Schema returns the schema of the object.

func (*UnresolvedObjectName) String 

func (u *UnresolvedObjectName) String() string

func (*UnresolvedObjectName) ToTableName 

func (u *UnresolvedObjectName) ToTableName() TableName

ToTableName converts the unresolved name to a table name.

TODO(radu): the schema and catalog names might not be in the right places; we would only figure that out during name resolution. This method is temporary, while we change all the code paths to only use TableName after resolution.

func (*UnresolvedObjectName) ToUnresolvedName 

func (u *UnresolvedObjectName) ToUnresolvedName() *UnresolvedName

ToUnresolvedName converts the unresolved object name to the more general unresolved name.

type UnrestrictedName 

type UnrestrictedName string

An UnrestrictedName is a Name that does not need to be escaped when it matches a reserved keyword.

In general, an UnrestrictedName is the result of parsing an unrestricted_name nonterminal, which is used in the grammar where reserved keywords can be unambiguously interpreted as identifiers. When formatted, an UnrestrictedName that matches a reserved keyword thus does not need to be quoted.

For historical reasons, some unrestricted_name nonterminals are instead parsed as Names. The only user-visible impact of this is that we are too aggressive about quoting names in certain positions. New grammar rules should prefer to parse unrestricted_name nonterminals into UnrestrictedNames.

func (*UnrestrictedName) Format 

func (u *UnrestrictedName) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*UnrestrictedName) String 

func (node *UnrestrictedName) String() string

type Unsplit 

type Unsplit struct {
	TableOrIndex TableIndexName
	// Each row contains values for the columns in the PK or index (or a prefix
	// of the columns).
	Rows *Select
	All  bool
}

Unsplit represents an `ALTER TABLE/INDEX .. UNSPLIT AT ..` statement.

func (*Unsplit) Format 

func (node *Unsplit) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Unsplit) StatementTag 

func (*Unsplit) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Unsplit) StatementType 

func (*Unsplit) StatementType() StatementType

StatementType implements the Statement interface.

func (*Unsplit) String 

func (n *Unsplit) String() string

type Update 

type Update struct {
	With      *With
	Table     TableExpr
	Exprs     UpdateExprs
	From      TableExprs
	Where     *Where
	OrderBy   OrderBy
	Limit     *Limit
	Returning ReturningClause
}

Update represents an UPDATE statement.

func (*Update) Format 

func (node *Update) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*Update) StatementTag 

func (*Update) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*Update) StatementType 

func (n *Update) StatementType() StatementType

StatementType implements the Statement interface.

func (*Update) String 

func (n *Update) String() string

type UpdateExpr 

type UpdateExpr struct {
	Tuple bool
	Names NameList
	Expr  Expr
}

UpdateExpr represents an update expression.

func (*UpdateExpr) Format 

func (node *UpdateExpr) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type UpdateExprs 

type UpdateExprs []*UpdateExpr

UpdateExprs represents a list of update expressions.

func (*UpdateExprs) Format 

func (node *UpdateExprs) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type UserPriority 

type UserPriority int

UserPriority holds the user priority for a transaction. 

const (
	UnspecifiedUserPriority UserPriority = iota
	Low
	Normal
	High
)

UserPriority values

func UserPriorityFromString 

func UserPriorityFromString(val string) (_ UserPriority, ok bool)

UserPriorityFromString converts a string into a UserPriority.

func (UserPriority) String 

func (up UserPriority) String() string

type UsingJoinCond 

type UsingJoinCond struct {
	Cols NameList
}

UsingJoinCond represents a USING join condition.

func (*UsingJoinCond) Format 

func (node *UsingJoinCond) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type ValidationBehavior 

type ValidationBehavior int

ValidationBehavior specifies whether or not a constraint is validated. 

const (
	// ValidationDefault is the default validation behavior (immediate).
	ValidationDefault ValidationBehavior = iota
	// ValidationSkip skips validation of any existing data.
	ValidationSkip
)

type ValueGenerator 

type ValueGenerator interface {
	// ResolvedType returns the type signature of this value generator.
	ResolvedType() *types.T

	// Next determines whether there is a row of data available.
	Next(context.Context) (bool, error)

	// Values retrieves the current row of data.
	Values() (Datums, error)

	// Close must be called after Start() before disposing of the
	// ValueGenerator. It does not need to be called if Start() has not
	// been called yet. It must not be called in-between restarts.
	Close()
}

ValueGenerator is the interface provided by the value generator functions for SQL SRfs. Objects that implement this interface are able to produce rows of values in a streaming fashion (like Go iterators or generators in Python).

type ValuesClause 

type ValuesClause struct {
	Rows []Exprs
}

ValuesClause represents a VALUES clause.

func (*ValuesClause) Format 

func (node *ValuesClause) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ValuesClause) StatementTag 

func (*ValuesClause) StatementTag() string

StatementTag returns a short string identifying the type of statement.

func (*ValuesClause) StatementType 

func (*ValuesClause) StatementType() StatementType

StatementType implements the Statement interface.

func (*ValuesClause) String 

func (n *ValuesClause) String() string

type ValuesClauseWithNames 

type ValuesClauseWithNames struct {
	ValuesClause

	// Names is a list of the column names that each tuple in the ValuesClause
	// corresponds to.
	Names NameList
}

ValuesClauseWithNames is a VALUES clause that has been annotated with column names. This is only produced at plan time, never by the parser. It's used to pass column names to the VALUES planNode, so it can produce intelligible error messages during value type checking.

type VarName 

type VarName interface {
	TypedExpr

	// NormalizeVarName() guarantees to return a variable name
	// that is not an UnresolvedName. This converts the UnresolvedName
	// to an AllColumnsSelector or ColumnItem as necessary.
	NormalizeVarName() (VarName, error)
}

VarName occurs inside scalar expressions.

Immediately after parsing, the following types can occur:

  • UnqualifiedStar: a naked star as argument to a function, e.g. count(*), or at the top level of a SELECT clause. See also uses of StarExpr() and StarSelectExpr() in the grammar.

- UnresolvedName: other names of the form `a.b....e` or `a.b...e.*`.

Consumers of variable names do not like UnresolvedNames and instead expect either AllColumnsSelector or ColumnItem. Use NormalizeVarName() for this.

After a ColumnItem is available, it should be further resolved, for this the Resolve() method should be used; see name_resolution.go.

func StarExpr 

func StarExpr() VarName

StarExpr is a convenience function that represents an unqualified "*".

type VariableExpr 

type VariableExpr interface {
	Expr
	Variable()
}

VariableExpr is an Expr that may change per row. It is used to signal the evaluation/simplification machinery that the underlying Expr is not constant.

type VariadicType 

type VariadicType struct {
	FixedTypes []*types.T
	VarType    *types.T
}

VariadicType is a TypeList implementation which accepts a fixed number of arguments at the beginning and an arbitrary number of homogenous arguments at the end.

func (VariadicType) GetAt 

func (v VariadicType) GetAt(i int) *types.T

GetAt is part of the TypeList interface.

func (VariadicType) Length 

func (v VariadicType) Length() int

Length is part of the TypeList interface.

func (VariadicType) Match 

func (v VariadicType) Match(types []*types.T) bool

Match is part of the TypeList interface.

func (VariadicType) MatchAt 

func (v VariadicType) MatchAt(typ *types.T, i int) bool

MatchAt is part of the TypeList interface.

func (VariadicType) MatchLen 

func (v VariadicType) MatchLen(l int) bool

MatchLen is part of the TypeList interface.

func (VariadicType) String 

func (v VariadicType) String() string

func (VariadicType) Types 

func (v VariadicType) Types() []*types.T

Types is part of the TypeList interface.

type Visitor 

type Visitor interface {
	// VisitPre is called for each node before recursing into that subast. Upon return, if recurse
	// is false, the visit will not recurse into the subtree (and VisitPost will not be called for
	// this node).
	//
	// The returned Expr replaces the visited expression and can be used for rewriting expressions.
	// The function should NOT modify nodes in-place; it should make copies of nodes. The Walk
	// infrastructure will automatically make copies of parents as needed.
	VisitPre(expr Expr) (recurse bool, newExpr Expr)

	// VisitPost is called for each node after recursing into the subast. The returned Expr
	// replaces the visited expression and can be used for rewriting expressions.
	//
	// The returned Expr replaces the visited expression and can be used for rewriting expressions.
	// The function should NOT modify nodes in-place; it should make and return copies of nodes. The
	// Walk infrastructure will automatically make copies of parents as needed.
	VisitPost(expr Expr) (newNode Expr)
}

Visitor defines methods that are called for nodes during an expression or statement walk.

type Volatility 

type Volatility int8

Volatility indicates whether the result of a function is dependent *only* on the values of its explicit arguments, or can change due to outside factors (such as parameter variables or table contents).

The values are ordered with smaller values being strictly more restrictive than larger values.

NOTE: functions having side-effects, such as setval(), must be labeled volatile to ensure they will not get optimized away, even if the actual return value is not changeable. 

const (
	// VolatilityLeakProof means that the operator cannot modify the database, the
	// transaction state, or any other state. It cannot depend on configuration
	// settings and is guaranteed to return the same results given the same
	// arguments in any context. In addition, no information about the arguments
	// is conveyed except via the return value. Any function that might throw an
	// error depending on the values of its arguments is not leak-proof.
	//
	// USE THIS WITH CAUTION! The optimizer might call operators that are leak
	// proof on inputs that they wouldn't normally be called on (e.g. pulling
	// expressions out of a CASE). In the future, they may even run on rows that
	// the user doesn't have permission to access.
	//
	// Note: VolatilityLeakProof is strictly stronger than VolatilityImmutable. In
	// principle it could be possible to have leak-proof stable or volatile
	// functions (perhaps now()); but this is not useful in practice as very few
	// operators are marked leak-proof.
	// Examples: integer comparison.
	VolatilityLeakProof Volatility = 1 + iota
	// VolatilityImmutable means that the operator cannot modify the database, the
	// transaction state, or any other state. It cannot depend on configuration
	// settings and is guaranteed to return the same results given the same
	// arguments in any context. Immutable operators can be constant folded.
	// Examples: log, from_json.
	VolatilityImmutable
	// VolatilityStable means that the operator cannot modify the database or the
	// transaction state and is guaranteed to return the same results given the
	// same arguments whenever it is evaluated within the same statement. Multiple
	// calls to a stable operator can be optimized to a single call.
	// Examples: current_timestamp, current_date.
	VolatilityStable
	// VolatilityVolatile means that the operator can do anything, including
	// modifying database state.
	// Examples: random, crdb_internal.force_error, nextval.
	VolatilityVolatile
)

func LookupCastVolatility 

func LookupCastVolatility(from, to *types.T) (_ Volatility, ok bool)

LookupCastVolatility returns the volatility of a valid cast.

func VolatilityFromPostgres 

func VolatilityFromPostgres(provolatile string, proleakproof bool) (Volatility, error)

VolatilityFromPostgres returns a Volatility that matches the postgres provolatile/proleakproof settings.

func (Volatility) String 

func (v Volatility) String() string

String returns the byte representation of Volatility as a string.

func (Volatility) ToPostgres 

func (v Volatility) ToPostgres() (provolatile string, proleakproof bool)

ToPostgres returns the postgres "provolatile" string ("i" or "s" or "v") and the "proleakproof" flag.

type When 

type When struct {
	Cond Expr
	Val  Expr
}

When represents a WHEN sub-expression.

func (*When) Format 

func (node *When) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type Where 

type Where struct {
	Type string
	Expr Expr
}

Where represents a WHERE or HAVING clause.

func NewWhere 

func NewWhere(typ string, expr Expr) *Where

NewWhere creates a WHERE or HAVING clause out of an Expr. If the expression is nil, it returns nil.

func (*Where) Format 

func (node *Where) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type Window 

type Window []*WindowDef

Window represents a WINDOW clause.

func (*Window) Format 

func (node *Window) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type WindowDef 

type WindowDef struct {
	Name       Name
	RefName    Name
	Partitions Exprs
	OrderBy    OrderBy
	Frame      *WindowFrame
}

WindowDef represents a single window definition expression.

func OverrideWindowDef 

func OverrideWindowDef(base *WindowDef, override WindowDef) (WindowDef, error)

OverrideWindowDef implements the logic to have a base window definition which then gets augmented by a different window definition.

func (*WindowDef) Format 

func (node *WindowDef) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type WindowFrame 

type WindowFrame struct {
	Mode      WindowFrameMode      // the mode of framing being used
	Bounds    WindowFrameBounds    // the bounds of the frame
	Exclusion WindowFrameExclusion // optional frame exclusion
}

WindowFrame represents static state of window frame over which calculations are made.

func (*WindowFrame) DefaultFrameExclusion 

func (f *WindowFrame) DefaultFrameExclusion() bool

DefaultFrameExclusion returns true if optional frame exclusion is omitted.

func (*WindowFrame) Format 

func (node *WindowFrame) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*WindowFrame) IsDefaultFrame 

func (f *WindowFrame) IsDefaultFrame() bool

IsDefaultFrame returns whether a frame equivalent to the default frame is being used (default is RANGE UNBOUNDED PRECEDING).

type WindowFrameBound 

type WindowFrameBound struct {
	BoundType  WindowFrameBoundType
	OffsetExpr Expr
}

WindowFrameBound specifies the offset and the type of boundary.

func (*WindowFrameBound) Format 

func (node *WindowFrameBound) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*WindowFrameBound) HasOffset 

func (node *WindowFrameBound) HasOffset() bool

HasOffset returns whether node contains an offset.

type WindowFrameBoundType 

type WindowFrameBoundType int

WindowFrameBoundType indicates which type of boundary is used. 

const (
	// UnboundedPreceding represents UNBOUNDED PRECEDING type of boundary.
	UnboundedPreceding WindowFrameBoundType = iota
	// OffsetPreceding represents 'value' PRECEDING type of boundary.
	OffsetPreceding
	// CurrentRow represents CURRENT ROW type of boundary.
	CurrentRow
	// OffsetFollowing represents 'value' FOLLOWING type of boundary.
	OffsetFollowing
	// UnboundedFollowing represents UNBOUNDED FOLLOWING type of boundary.
	UnboundedFollowing
)

type WindowFrameBounds 

type WindowFrameBounds struct {
	StartBound *WindowFrameBound
	EndBound   *WindowFrameBound
}

WindowFrameBounds specifies boundaries of the window frame. The row at StartBound is included whereas the row at EndBound is not.

func (*WindowFrameBounds) HasOffset 

func (node *WindowFrameBounds) HasOffset() bool

HasOffset returns whether node contains an offset in either of the bounds.

type WindowFrameExclusion 

type WindowFrameExclusion int

WindowFrameExclusion indicates which mode of exclusion is used. 

const (
	// NoExclusion represents an omitted frame exclusion clause.
	NoExclusion WindowFrameExclusion = iota
	// ExcludeCurrentRow represents EXCLUDE CURRENT ROW mode of frame exclusion.
	ExcludeCurrentRow
	// ExcludeGroup represents EXCLUDE GROUP mode of frame exclusion.
	ExcludeGroup
	// ExcludeTies represents EXCLUDE TIES mode of frame exclusion.
	ExcludeTies
)

func (WindowFrameExclusion) Format 

func (node WindowFrameExclusion) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type WindowFrameMode 

type WindowFrameMode int

WindowFrameMode indicates which mode of framing is used. 

const (
	// RANGE is the mode of specifying frame in terms of logical range (e.g. 100 units cheaper).
	RANGE WindowFrameMode = iota
	// ROWS is the mode of specifying frame in terms of physical offsets (e.g. 1 row before etc).
	ROWS
	// GROUPS is the mode of specifying frame in terms of peer groups.
	GROUPS
)

type WindowFrameRangeOps 

type WindowFrameRangeOps struct{}

WindowFrameRangeOps allows for looking up an implementation of binary operators necessary for RANGE mode of framing.

func (WindowFrameRangeOps) LookupImpl 

func (o WindowFrameRangeOps) LookupImpl(left, right *types.T) (*BinOp, *BinOp, bool)

LookupImpl looks up implementation of Plus and Minus binary operators for provided left and right types and returns them along with a boolean which indicates whether lookup is successful.

type WindowFrameRun 

type WindowFrameRun struct {
	// constant for all calls to WindowFunc.Add
	Rows             IndexedRows
	ArgsIdxs         []uint32     // indices of the arguments to the window function
	Frame            *WindowFrame // If non-nil, Frame represents the frame specification of this window. If nil, default frame is used.
	StartBoundOffset Datum
	EndBoundOffset   Datum
	FilterColIdx     int
	OrdColIdx        int                // Column over which rows are ordered within the partition. It is only required in RANGE mode.
	OrdDirection     encoding.Direction // Direction of the ordering over OrdColIdx.
	PlusOp, MinusOp  *BinOp             // Binary operators for addition and subtraction required only in RANGE mode.
	PeerHelper       PeerGroupsIndicesHelper

	// changes for each peer group
	CurRowPeerGroupNum int // the number of the current row's peer group

	// changes for each row (each call to WindowFunc.Add)
	RowIdx int // the current row index
	// contains filtered or unexported fields
}

WindowFrameRun contains the runtime state of window frame during calculations.

func (*WindowFrameRun) Args 

func (wfr *WindowFrameRun) Args(ctx context.Context) (Datums, error)

Args returns the current argument set in the window frame.

func (*WindowFrameRun) ArgsByRowIdx 

func (wfr *WindowFrameRun) ArgsByRowIdx(ctx context.Context, idx int) (Datums, error)

ArgsByRowIdx returns the argument set of the row at idx.

func (*WindowFrameRun) ArgsWithRowOffset 

func (wfr *WindowFrameRun) ArgsWithRowOffset(ctx context.Context, offset int) (Datums, error)

ArgsWithRowOffset returns the argument set at the given offset in the window frame.

func (*WindowFrameRun) DefaultFrameSize 

func (wfr *WindowFrameRun) DefaultFrameSize() int

DefaultFrameSize returns the size of default window frame which contains the rows from the start of the partition through the last peer of the current row.

func (*WindowFrameRun) FirstInPeerGroup 

func (wfr *WindowFrameRun) FirstInPeerGroup() bool

FirstInPeerGroup returns if the current row is the first in its peer group.

func (*WindowFrameRun) FrameEndIdx 

func (wfr *WindowFrameRun) FrameEndIdx(ctx context.Context, evalCtx *EvalContext) (int, error)

FrameEndIdx returns the index of the first row after the frame.

func (*WindowFrameRun) FrameSize 

func (wfr *WindowFrameRun) FrameSize(ctx context.Context, evalCtx *EvalContext) (int, error)

FrameSize returns the number of rows in the current frame (taking into account - if present - a filter and a frame exclusion).

func (*WindowFrameRun) FrameStartIdx 

func (wfr *WindowFrameRun) FrameStartIdx(ctx context.Context, evalCtx *EvalContext) (int, error)

FrameStartIdx returns the index of starting row in the frame (which is the first to be included).

func (*WindowFrameRun) FullPartitionIsInWindow 

func (wfr *WindowFrameRun) FullPartitionIsInWindow() bool

FullPartitionIsInWindow checks whether we have such a window frame that all rows of the partition are inside of the window for each of the rows.

func (*WindowFrameRun) IsRowSkipped 

func (wfr *WindowFrameRun) IsRowSkipped(ctx context.Context, idx int) (bool, error)

IsRowSkipped returns whether a row at index idx is skipped from the window frame (it can either be filtered out according to the filter clause or excluded according to the frame exclusion clause) and any error if it occurs.

func (*WindowFrameRun) PartitionSize 

func (wfr *WindowFrameRun) PartitionSize() int

PartitionSize returns the number of rows in the current partition.

func (*WindowFrameRun) RangeModeWithOffsets 

func (wfr *WindowFrameRun) RangeModeWithOffsets() bool

RangeModeWithOffsets returns whether the frame is in RANGE mode with at least one of the bounds containing an offset.

func (*WindowFrameRun) Rank 

func (wfr *WindowFrameRun) Rank() int

Rank returns the rank of the current row.

type WindowFunc 

type WindowFunc interface {
	// Compute computes the window function for the provided window frame, given the
	// current state of WindowFunc. The method should be called sequentially for every
	// row in a partition in turn with the desired ordering of the WindowFunc. This is
	// because there is an implicit carried dependency between each row and all those
	// that have come before it (like in an AggregateFunc). As such, this approach does
	// not present any exploitable associativity/commutativity for optimization.
	Compute(context.Context, *EvalContext, *WindowFrameRun) (Datum, error)

	// Reset resets the window function which allows for reusing it when
	// computing over different partitions.
	Reset(context.Context)

	// Close allows the window function to free any memory it requested during execution,
	// such as during the execution of an aggregation like CONCAT_AGG or ARRAY_AGG.
	Close(context.Context, *EvalContext)
}

WindowFunc performs a computation on each row using data from a provided *WindowFrameRun.

type With 

type With struct {
	Recursive bool
	CTEList   []*CTE
}

With represents a WITH statement.

func (*With) Format 

func (node *With) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

type ZoneSpecifier 

type ZoneSpecifier struct {
	// Only one of NamedZone, Database or TableOrIndex may be set.
	NamedZone UnrestrictedName
	Database  Name
	// TODO(radu): TableOrIndex abuses TableIndexName: it allows for the case when
	// an index is not specified, in which case TableOrIndex.Index is empty.
	TableOrIndex TableIndexName

	// Partition is only respected when Table is set.
	Partition Name
}

ZoneSpecifier represents a reference to a configurable zone of the keyspace.

func (*ZoneSpecifier) Format 

func (node *ZoneSpecifier) Format(ctx *FmtCtx)

Format implements the NodeFormatter interface.

func (*ZoneSpecifier) String 

func (node *ZoneSpecifier) String() string

func (ZoneSpecifier) TargetsIndex 

func (node ZoneSpecifier) TargetsIndex() bool

TargetsIndex returns whether the zone specifier targets an index.

func (ZoneSpecifier) TargetsPartition 

func (node ZoneSpecifier) TargetsPartition() bool

TargetsPartition returns whether the zone specifier targets a partition.

func (ZoneSpecifier) TargetsTable 

func (node ZoneSpecifier) TargetsTable() bool

TargetsTable returns whether the zone specifier targets a table or a subzone within a table.

func (ZoneSpecifier) TelemetryName 

func (node ZoneSpecifier) TelemetryName() string

TelemetryName returns a name fitting for telemetry purposes.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.