Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
- API
  
  Reference documentation for the pkg.go.dev API
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

parser

package

Go to main page

Versions in this module

v1

v1.1.9

Oct 1, 2018

Changes in this version

+ const ACTION

+ const ADD

+ const ALL

+ const ALTER

+ const ANALYSE

+ const ANALYZE

+ const AND

+ const ANNOTATE_TYPE

+ const ANY

+ const ARRAY

+ const AS

+ const ASC

+ const ASYMMETRIC

+ const AS_LA

+ const AT

+ const AllFuncType

+ const BACKUP

+ const BCONST

+ const BEGIN

+ const BETWEEN

+ const BIGINT

+ const BIGSERIAL

+ const BIT

+ const BLOB

+ const BOOL

+ const BOOLEAN

+ const BOTH

+ const BY

+ const BYTEA

+ const BYTES

+ const CANCEL

+ const CASCADE

+ const CASE

+ const CAST

+ const CHAR

+ const CHARACTER

+ const CHARACTERISTICS

+ const CHECK

+ const CLUSTER

+ const COALESCE

+ const COLLATE

+ const COLLATION

+ const COLUMN

+ const COLUMNS

+ const COMMIT

+ const COMMITTED

+ const CONCAT

+ const CONFLICT

+ const CONSTRAINT

+ const CONSTRAINTS

+ const COPY

+ const COVERING

+ const CREATE

+ const CROSS

+ const CSV

+ const CUBE

+ const CURRENT

+ const CURRENT_CATALOG

+ const CURRENT_DATE

+ const CURRENT_ROLE

+ const CURRENT_SCHEMA

+ const CURRENT_TIME

+ const CURRENT_TIMESTAMP

+ const CURRENT_USER

+ const CYCLE

+ const DATA

+ const DATABASE

+ const DATABASES

+ const DATE

+ const DAY

+ const DEALLOCATE

+ const DEC

+ const DECIMAL

+ const DEFAULT

+ const DEFERRABLE

+ const DELETE

+ const DESC

+ const DISCARD

+ const DISTINCT

+ const DO

+ const DOT_DOT

+ const DOUBLE

+ const DROP

+ const DistinctFuncType

+ const ELSE

+ const ENCODING

+ const END

+ const ERROR

+ const ESCAPE

+ const EXCEPT

+ const EXECUTE

+ const EXISTS

+ const EXPERIMENTAL_FINGERPRINTS

+ const EXPLAIN

+ const EXTRACT

+ const EXTRACT_DURATION

+ const FALSE

+ const FAMILY

+ const FCONST

+ const FETCH

+ const FILTER

+ const FIRST

+ const FLOAT

+ const FLOAT4

+ const FLOAT8

+ const FLOORDIV

+ const FOLLOWING

+ const FOR

+ const FORCE_INDEX

+ const FOREIGN

+ const FROM

+ const FULL

+ const GRANT

+ const GRANTS

+ const GREATER_EQUALS

+ const GREATEST

+ const GROUP

+ const GROUPING

+ const HAVING

+ const HELP

+ const HELPTOKEN

+ const HIGH

+ const HOUR

+ const ICONST

+ const IDENT

+ const IF

+ const IFNULL

+ const ILIKE

+ const IMPORT

+ const IN

+ const INCREMENTAL

+ const INDEX

+ const INDEXES

+ const INITIALLY

+ const INNER

+ const INSERT

+ const INT

+ const INT2

+ const INT2VECTOR

+ const INT4

+ const INT64

+ const INT8

+ const INTEGER

+ const INTERLEAVE

+ const INTERSECT

+ const INTERVAL

+ const INTO

+ const IS

+ const ISOLATION

+ const InvalidColIdx

+ const JOB

+ const JOBS

+ const JOIN

+ const KEY

+ const KEYS

+ const KV

+ const LATERAL

+ const LC_COLLATE

+ const LC_CTYPE

+ const LEADING

+ const LEAST

+ const LEFT

+ const LESS_EQUALS

+ const LEVEL

+ const LIKE

+ const LIMIT

+ const LOCAL

+ const LOCALTIME

+ const LOCALTIMESTAMP

+ const LOW

+ const LSHIFT

+ const MATCH

+ const MINUTE

+ const MONTH

+ const MaxInt

+ const MaxUint

+ const NAME

+ const NAMES

+ const NAN

+ const NATURAL

+ const NEXT

+ const NO

+ const NORMAL

+ const NOT

+ const NOTHING

+ const NOT_EQUALS

+ const NOT_LA

+ const NOT_REGIMATCH

+ const NOT_REGMATCH

+ const NO_INDEX_JOIN

+ const NULL

+ const NULLIF

+ const NULLS

+ const NUMERIC

+ const OF

+ const OFF

+ const OFFSET

+ const OID

+ const ON

+ const ONLY

+ const OPTIONS

+ const OR

+ const ORDER

+ const ORDINALITY

+ const OUT

+ const OUTER

+ const OVER

+ const OVERLAPS

+ const OVERLAY

+ const PARENT

+ const PARTIAL

+ const PARTITION

+ const PASSWORD

+ const PAUSE

+ const PLACEHOLDER

+ const PLACING

+ const PLANS

+ const POSITION

+ const POSTFIXOP

+ const PRECEDING

+ const PRECISION

+ const PREPARE

+ const PRIMARY

+ const PRIORITY

+ const QUERIES

+ const QUERY

+ const RANGE

+ const READ

+ const REAL

+ const RECURSIVE

+ const REF

+ const REFERENCES

+ const REGCLASS

+ const REGIMATCH

+ const REGNAMESPACE

+ const REGPROC

+ const REGPROCEDURE

+ const REGTYPE

+ const RELEASE

+ const RENAME

+ const REPEATABLE

+ const RESET

+ const RESTORE

+ const RESTRICT

+ const RESUME

+ const RETURNING

+ const REVOKE

+ const RIGHT

+ const ROLLBACK

+ const ROLLUP

+ const ROW

+ const ROWS

+ const RSHIFT

+ const RestartSavepointName

+ const SAVEPOINT

+ const SCATTER

+ const SCONST

+ const SEARCH

+ const SECOND

+ const SELECT

+ const SEQUENCES

+ const SERIAL

+ const SERIALIZABLE

+ const SESSION

+ const SESSIONS

+ const SESSION_USER

+ const SET

+ const SETTING

+ const SETTINGS

+ const SHOW

+ const SIMILAR

+ const SIMPLE

+ const SMALLINT

+ const SMALLSERIAL

+ const SNAPSHOT

+ const SOME

+ const SPLIT

+ const SQL

+ const START

+ const STATUS

+ const STDIN

+ const STORE

+ const STORING

+ const STRICT

+ const STRING

+ const SUBSTRING

+ const SYMMETRIC

+ const SYSTEM

+ const TABLE

+ const TABLES

+ const TEMP

+ const TEMPLATE

+ const TEMPORARY

+ const TESTING_RANGES

+ const TESTING_RELOCATE

+ const TEXT

+ const THEN

+ const TIME

+ const TIMESTAMP

+ const TIMESTAMPTZ

+ const TO

+ const TRACE

+ const TRAILING

+ const TRANSACTION

+ const TREAT

+ const TRIM

+ const TRUE

+ const TRUNCATE

+ const TYPE

+ const TYPEANNOTATE

+ const TYPECAST

+ const TimestampOutputFormat

+ const UMINUS

+ const UNBOUNDED

+ const UNCOMMITTED

+ const UNION

+ const UNIQUE

+ const UNKNOWN

+ const UPDATE

+ const UPSERT

+ const USE

+ const USER

+ const USERS

+ const USING

+ const UUID

+ const VALID

+ const VALIDATE

+ const VALUE

+ const VALUES

+ const VARCHAR

+ const VARIADIC

+ const VARYING

+ const VIEW

+ const WHEN

+ const WHERE

+ const WINDOW

+ const WITH

+ const WITHIN

+ const WITHOUT

+ const WITH_LA

+ const WRITE

+ const YEAR

+ const ZONE

+ var AbsentReturningClause = &NoReturningClause

+ var Aggregates = map[string][]Builtin

+ var AllBuiltinNames []string

+ var AllHelp = func(h map[string]HelpMessageBody) string { ... }(helpMessages)

+ var ArrayOids = map[oid.Oid]struct{}

+ var BinOps = map[BinaryOperator]binOpOverload

+ var Builtins = map[string][]Builtin

+ var CmpOps = map[ComparisonOperator]cmpOpOverload

+ var DBoolFalse = &constDBoolFalse

+ var DBoolTrue = &constDBoolTrue

+ var DNull Datum = dNull

+ var DZero = NewDInt(0)

+ var DecimalCtx = &apd.Context

+ var ExactCtx = DecimalCtx.WithPrecision(0)

+ var Generators = map[string][]Builtin

+ var HelpMessages = func(h map[string]HelpMessageBody) map[string]HelpMessageBody { ... }(helpMessages)

+ var HighPrecisionCtx = DecimalCtx.WithPrecision(2000)

+ var OidToType = map[oid.Oid]Type

+ var RoundCtx = func() *apd.Context { ... }()

+ var TypeAny Type = tAny

+ var TypeAnyArray Type = TArray

+ var TypeArray Type = TArray

+ var TypeBool Type = tBool

+ var TypeBytes Type = tBytes

+ var TypeCollatedString Type = TCollatedString

+ var TypeDate Type = tDate

+ var TypeDecimal Type = tDecimal

+ var TypeFloat Type = tFloat

+ var TypeInt Type = tInt

+ var TypeIntVector = wrapTypeWithOid(TArray{ ... }, oid.T_int2vector)

+ var TypeInterval Type = tInterval

+ var TypeName = wrapTypeWithOid(TypeString, oid.T_name)

+ var TypeNameArray Type = TArray

+ var TypeNull Type = tNull

+ var TypeOid = tOid

+ var TypePlaceholder Type = TPlaceholder

+ var TypeRegClass = tOid

+ var TypeRegNamespace = tOid

+ var TypeRegProc = tOid

+ var TypeRegProcedure = tOid

+ var TypeRegType = tOid

+ var TypeString Type = tString

+ var TypeTable Type = TTable

+ var TypeTimestamp Type = tTimestamp

+ var TypeTimestampTZ Type = tTimestampTZ

+ var TypeTuple Type = TTuple(nil)

+ var TypeUUID Type = tUUID

+ var TypesAnyNonArray = []Type

+ var UnaryOps = map[UnaryOperator]unaryOpOverload

+ func AsString(n NodeFormatter) string

+ func AsStringWithFlags(n NodeFormatter, f FmtFlags) string

+ func ContainsVars(expr Expr) bool

+ func ErrString(n NodeFormatter) string

+ func EscapeSQLString(in string) string

+ func ExprDebugString(expr Expr) string

+ func FindEqualComparisonFunction(leftType, rightType Type) (func(*EvalContext, Datum, Datum) (Datum, error), bool)

+ func FormatNode(buf *bytes.Buffer, f FmtFlags, n NodeFormatter)

+ func HasReturningClause(clause ReturningClause) bool

+ func IsNumericOne(expr TypedExpr) bool

+ func IsNumericZero(expr TypedExpr) bool

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

+ func NewInvalidNameErrorf(fmt string, args ...interface{}) error

+ func PGDisplayName(typ Type) string

+ func PGIOBuiltinPrefix(typ Type) string

+ func Serialize(n NodeFormatter) string

+ func SimilarEscape(pattern string) string

+ func StmtDebugString(stmt Statement) string

+ func ValidateRestartCheckpoint(savepoint string) error

+ func WalkExprConst(v Visitor, expr Expr)

+ type AggregateFunc interface

+ Add func(context.Context, Datum) error

+ Close func(context.Context)

+ Result func() (Datum, error)

+ func NewIdentAggregate(*EvalContext) AggregateFunc

+ type AliasClause struct

+ Alias Name

+ Cols NameList

+ func (a AliasClause) Format(buf *bytes.Buffer, f FmtFlags)

+ type AliasedTableExpr struct

+ As AliasClause

+ Expr TableExpr

+ Hints *IndexHints

+ Ordinality bool

+ func (node *AliasedTableExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *AliasedTableExpr) String() string

+ type AllColumnsSelector struct

+ func (*AllColumnsSelector) ResolvedType() Type

+ func (a *AllColumnsSelector) Format(buf *bytes.Buffer, f FmtFlags)

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

+ func (a *AllColumnsSelector) String() string

+ func (a *AllColumnsSelector) Variable()

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

+ func (expr *AllColumnsSelector) TypeCheck(_ *SemaContext, desired Type) (TypedExpr, error)

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

+ type AllTablesSelector struct

+ DBNameOriginallyOmitted bool

+ Database Name

+ func (at *AllTablesSelector) Format(buf *bytes.Buffer, f FmtFlags)

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

+ func (at *AllTablesSelector) QualifyWithDatabase(database string) error

+ func (at *AllTablesSelector) String() string

+ type AlterTable struct

+ Cmds AlterTableCmds

+ IfExists bool

+ Table NormalizableTableName

+ func (*AlterTable) StatementTag() string

+ func (*AlterTable) StatementType() StatementType

+ func (n *AlterTable) String() string

+ func (node *AlterTable) Format(buf *bytes.Buffer, f FmtFlags)

+ type AlterTableAddColumn struct

+ ColumnDef *ColumnTableDef

+ IfNotExists bool

+ func (n *AlterTableAddColumn) String() string

+ func (node *AlterTableAddColumn) Format(buf *bytes.Buffer, f FmtFlags)

+ type AlterTableAddConstraint struct

+ ConstraintDef ConstraintTableDef

+ ValidationBehavior ValidationBehavior

+ func (n *AlterTableAddConstraint) String() string

+ func (node *AlterTableAddConstraint) Format(buf *bytes.Buffer, f FmtFlags)

+ type AlterTableCmd interface

+ type AlterTableCmds []AlterTableCmd

+ func (n AlterTableCmds) String() string

+ func (node AlterTableCmds) Format(buf *bytes.Buffer, f FmtFlags)

+ type AlterTableDropColumn struct

+ Column Name

+ DropBehavior DropBehavior

+ IfExists bool

+ func (n *AlterTableDropColumn) String() string

+ func (node *AlterTableDropColumn) Format(buf *bytes.Buffer, f FmtFlags)

+ type AlterTableDropConstraint struct

+ Constraint Name

+ DropBehavior DropBehavior

+ IfExists bool

+ func (n *AlterTableDropConstraint) String() string

+ func (node *AlterTableDropConstraint) Format(buf *bytes.Buffer, f FmtFlags)

+ type AlterTableDropNotNull struct

+ Column Name

+ func (n *AlterTableDropNotNull) String() string

+ func (node *AlterTableDropNotNull) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *AlterTableDropNotNull) GetColumn() Name

+ type AlterTableSetDefault struct

+ Column Name

+ Default Expr

+ func (n *AlterTableSetDefault) String() string

+ func (node *AlterTableSetDefault) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *AlterTableSetDefault) GetColumn() Name

+ type AlterTableValidateConstraint struct

+ Constraint Name

+ func (node *AlterTableValidateConstraint) Format(buf *bytes.Buffer, f FmtFlags)

+ type AndExpr struct

+ Left Expr

+ Right Expr

+ func NewTypedAndExpr(left, right TypedExpr) *AndExpr

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

+ func (expr *AndExpr) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

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

+ func (node *AndExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *AndExpr) String() string

+ func (node *AndExpr) TypedLeft() TypedExpr

+ func (node *AndExpr) TypedRight() TypedExpr

+ func (ta AndExpr) ResolvedType() Type

+ type AnnotateTypeExpr struct

+ Expr Expr

+ Type CastTargetType

+ func (expr *AnnotateTypeExpr) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

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

+ func (node *AnnotateTypeExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *AnnotateTypeExpr) String() string

+ func (node *AnnotateTypeExpr) TypedInnerExpr() TypedExpr

+ type ArgTypes []struct

+ func (a ArgTypes) Length() int

+ func (a ArgTypes) String() string

+ func (a ArgTypes) Types() []Type

+ type Array struct

+ Exprs Exprs

+ func (expr *Array) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

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

+ func (node *Array) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *Array) String() string

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

+ func (ta Array) ResolvedType() Type

+ type ArrayColType struct

+ BoundsExprs Exprs

+ Name string

+ ParamType ColumnType

+ func (node *ArrayColType) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *ArrayColType) String() string

+ type ArrayFlatten struct

+ Subquery Expr

+ func (expr *ArrayFlatten) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

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

+ func (node *ArrayFlatten) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *ArrayFlatten) String() string

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

+ func (ta ArrayFlatten) ResolvedType() Type

+ type ArraySubscript struct

+ Begin Expr

+ End Expr

+ Slice bool

+ func (a *ArraySubscript) Format(buf *bytes.Buffer, f FmtFlags)

+ type ArraySubscripts []*ArraySubscript

+ func (a ArraySubscripts) Format(buf *bytes.Buffer, f FmtFlags)

+ type AsOfClause struct

+ Expr Expr

+ func (a AsOfClause) Format(buf *bytes.Buffer, f FmtFlags)

+ type Backup struct

+ AsOf AsOfClause

+ IncrementalFrom Exprs

+ Options KVOptions

+ Targets TargetList

+ To Expr

+ func (*Backup) StatementTag() string

+ func (*Backup) StatementType() StatementType

+ func (n *Backup) String() string

+ func (node *Backup) Format(buf *bytes.Buffer, f FmtFlags)

+ func (stmt *Backup) CopyNode() *Backup

+ func (stmt *Backup) WalkStmt(v Visitor) Statement

+ type BeginTransaction struct

+ Modes TransactionModes

+ func (*BeginTransaction) StatementTag() string

+ func (*BeginTransaction) StatementType() StatementType

+ func (n *BeginTransaction) String() string

+ func (node *BeginTransaction) Format(buf *bytes.Buffer, f FmtFlags)

+ type BinOp struct

+ LeftType Type

+ ReturnType Type

+ RightType Type

+ type BinaryExpr struct

+ Left Expr

+ Operator BinaryOperator

+ Right Expr

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

+ func (expr *BinaryExpr) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

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

+ func (node *BinaryExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *BinaryExpr) String() string

+ func (node *BinaryExpr) TypedLeft() TypedExpr

+ func (node *BinaryExpr) TypedRight() TypedExpr

+ func (ta BinaryExpr) ResolvedType() Type

+ type BinaryOperator int

+ const Bitand

+ const Bitor

+ const Bitxor

+ const Concat

+ const Div

+ const FloorDiv

+ const LShift

+ const Minus

+ const Mod

+ const Mult

+ const Plus

+ const Pow

+ const RShift

+ func (i BinaryOperator) String() string

+ type BoolColType struct

+ Name string

+ func (node *BoolColType) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *BoolColType) String() string

+ type Builtin struct

+ AggregateFunc func([]Type, *EvalContext) AggregateFunc

+ Info string

+ ReturnType returnTyper

+ Types typeList

+ WindowFunc func([]Type, *EvalContext) WindowFunc

+ func (b Builtin) Category() string

+ func (b Builtin) Class() FunctionClass

+ func (b Builtin) DistSQLBlacklist() bool

+ func (b Builtin) FixedReturnType() Type

+ func (b Builtin) Fn() func(*EvalContext, Datums) (Datum, error)

+ func (b Builtin) Impure() bool

+ func (b Builtin) Signature() string

+ type BytesColType struct

+ Name string

+ func (node *BytesColType) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *BytesColType) String() string

+ type CancelJob struct

+ ID Expr

+ func (*CancelJob) StatementTag() string

+ func (*CancelJob) StatementType() StatementType

+ func (n *CancelJob) String() string

+ func (node *CancelJob) Format(buf *bytes.Buffer, f FmtFlags)

+ type CancelQuery struct

+ ID Expr

+ func (*CancelQuery) StatementTag() string

+ func (*CancelQuery) StatementType() StatementType

+ func (n *CancelQuery) String() string

+ func (node *CancelQuery) Format(buf *bytes.Buffer, f FmtFlags)

+ type CaseExpr struct

+ Else Expr

+ Expr Expr

+ Whens []*When

+ func (expr *CaseExpr) CopyNode() *CaseExpr

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

+ func (expr *CaseExpr) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

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

+ func (node *CaseExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *CaseExpr) String() string

+ func (ta CaseExpr) ResolvedType() Type

+ type CastExpr struct

+ Expr Expr

+ Type CastTargetType

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

+ func (expr *CastExpr) TypeCheck(ctx *SemaContext, _ Type) (TypedExpr, error)

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

+ func (node *CastExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *CastExpr) String() string

+ func (ta CastExpr) ResolvedType() Type

+ type CastTargetType interface

+ func ParseType(sql string) (CastTargetType, error)

+ type CheckConstraintTableDef struct

+ Expr Expr

+ Name Name

+ func (node *CheckConstraintTableDef) Format(buf *bytes.Buffer, f FmtFlags)

+ type CmpOp struct

+ LeftType Type

+ RightType Type

+ type CoalesceExpr struct

+ Exprs Exprs

+ Name string

+ func (expr *CoalesceExpr) CopyNode() *CoalesceExpr

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

+ func (expr *CoalesceExpr) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

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

+ func (node *CoalesceExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *CoalesceExpr) String() string

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

+ func (ta CoalesceExpr) ResolvedType() Type

+ type CollateExpr struct

+ Expr Expr

+ Locale string

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

+ func (expr *CollateExpr) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

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

+ func (node *CollateExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *CollateExpr) String() string

+ func (ta CollateExpr) ResolvedType() Type

+ type CollatedStringColType struct

+ Locale string

+ N int

+ Name string

+ func (node *CollatedStringColType) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *CollatedStringColType) String() string

+ type CollationEnvironment struct

+ type ColumnCheckConstraint struct

+ Expr Expr

+ type ColumnCollation string

+ type ColumnDefault struct

+ Expr Expr

+ type ColumnFKConstraint struct

+ Col Name

+ Table NormalizableTableName

+ type ColumnFamilyConstraint struct

+ Create bool

+ Family Name

+ IfNotExists bool

+ type ColumnID uint32

+ type ColumnItem struct

+ ColumnName Name

+ Selector NameParts

+ TableName TableName

+ func (c *ColumnItem) Column() string

+ func (c *ColumnItem) Format(buf *bytes.Buffer, f FmtFlags)

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

+ func (c *ColumnItem) ResolvedType() Type

+ func (c *ColumnItem) String() string

+ func (c *ColumnItem) Variable()

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

+ func (expr *ColumnItem) TypeCheck(_ *SemaContext, desired Type) (TypedExpr, error)

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

+ type ColumnMutationCmd interface

+ GetColumn func() Name

+ type ColumnQualification interface

+ type ColumnTableDef struct

+ CheckExprs []ColumnTableDefCheckExpr

+ DefaultExpr struct{ ... }

+ Family struct{ ... }

+ Name Name

+ Nullable struct{ ... }

+ PrimaryKey bool

+ References struct{ ... }

+ Type ColumnType

+ Unique bool

+ UniqueConstraintName Name

+ func (node *ColumnTableDef) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *ColumnTableDef) HasColumnFamily() bool

+ func (node *ColumnTableDef) HasDefaultExpr() bool

+ func (node *ColumnTableDef) HasFKConstraint() bool

+ type ColumnTableDefCheckExpr struct

+ ConstraintName Name

+ Expr Expr

+ type ColumnType interface

+ func DatumTypeToColumnType(t Type) (ColumnType, error)

+ func StringToColType(s string) (ColumnType, error)

+ type CommitTransaction struct

+ func (*CommitTransaction) StatementTag() string

+ func (*CommitTransaction) StatementType() StatementType

+ func (n *CommitTransaction) String() string

+ func (node *CommitTransaction) Format(buf *bytes.Buffer, f FmtFlags)

+ type ComparisonExpr struct

+ Left Expr

+ Operator ComparisonOperator

+ Right Expr

+ SubOperator ComparisonOperator

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

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

+ func (expr *ComparisonExpr) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

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

+ func (node *ComparisonExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *ComparisonExpr) IsMixedTypeComparison() bool

+ func (node *ComparisonExpr) String() string

+ func (node *ComparisonExpr) TypedLeft() TypedExpr

+ func (node *ComparisonExpr) TypedRight() TypedExpr

+ func (ta ComparisonExpr) ResolvedType() Type

+ type ComparisonOperator int

+ const All

+ const Any

+ const EQ

+ const GE

+ const GT

+ const ILike

+ const In

+ const Is

+ const IsDistinctFrom

+ const IsNot

+ const IsNotDistinctFrom

+ const LE

+ const LT

+ const Like

+ const NE

+ const NotILike

+ const NotIn

+ const NotLike

+ const NotRegIMatch

+ const NotRegMatch

+ const NotSimilarTo

+ const RegIMatch

+ const RegMatch

+ const SimilarTo

+ const Some

+ func (i ComparisonOperator) String() string

+ type CompositeDatum interface

+ IsComposite func() bool

+ type Constant interface

+ AvailableTypes func() []Type

+ DesirableTypes func() []Type

+ ResolveAsType func(*SemaContext, Type) (Datum, error)

+ type ConstraintTableDef interface

+ type ContainsWindowVisitor struct

+ func (*ContainsWindowVisitor) VisitPost(expr Expr) Expr

+ func (v *ContainsWindowVisitor) ContainsWindowFunc(expr Expr) bool

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

+ type CopyFrom struct

+ Columns UnresolvedNames

+ Stdin bool

+ Table NormalizableTableName

+ func (*CopyFrom) StatementTag() string

+ func (*CopyFrom) StatementType() StatementType

+ func (n *CopyFrom) String() string

+ func (node *CopyFrom) Format(buf *bytes.Buffer, f FmtFlags)

+ type CreateDatabase struct

+ CType string

+ Collate string

+ Encoding string

+ IfNotExists bool

+ Name Name

+ Template string

+ func (*CreateDatabase) StatementTag() string

+ func (*CreateDatabase) StatementType() StatementType

+ func (n *CreateDatabase) String() string

+ func (node *CreateDatabase) Format(buf *bytes.Buffer, f FmtFlags)

+ type CreateIndex struct

+ Columns IndexElemList

+ IfNotExists bool

+ Interleave *InterleaveDef

+ Name Name

+ Storing NameList

+ Table NormalizableTableName

+ Unique bool

+ func (*CreateIndex) StatementTag() string

+ func (*CreateIndex) StatementType() StatementType

+ func (n *CreateIndex) String() string

+ func (node *CreateIndex) Format(buf *bytes.Buffer, f FmtFlags)

+ type CreateTable struct

+ AsColumnNames NameList

+ AsSource *Select

+ Defs TableDefs

+ IfNotExists bool

+ Interleave *InterleaveDef

+ Table NormalizableTableName

+ func (*CreateTable) StatementType() StatementType

+ func (n *CreateTable) StatementTag() string

+ func (n *CreateTable) String() string

+ func (node *CreateTable) As() bool

+ func (node *CreateTable) Format(buf *bytes.Buffer, f FmtFlags)

+ type CreateUser struct

+ Name Name

+ Password *string

+ func (*CreateUser) StatementTag() string

+ func (*CreateUser) StatementType() StatementType

+ func (n *CreateUser) String() string

+ func (node *CreateUser) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *CreateUser) HasPassword() bool

+ type CreateView struct

+ AsSource *Select

+ ColumnNames NameList

+ Name NormalizableTableName

+ func (*CreateView) StatementTag() string

+ func (*CreateView) StatementType() StatementType

+ func (n *CreateView) String() string

+ func (node *CreateView) Format(buf *bytes.Buffer, f FmtFlags)

+ type DArray struct

+ Array Datums

+ HasNulls bool

+ ParamTyp Type

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

+ func MustBeDArray(e Expr) *DArray

+ func NewDArray(paramTyp Type) *DArray

+ func ParseDArrayFromString(evalCtx *EvalContext, s string, t ColumnType) (*DArray, error)

+ func (*DArray) AmbiguousFormat() bool

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

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

+ func (d *DArray) Format(buf *bytes.Buffer, f FmtFlags)

+ func (d *DArray) IsMax() bool

+ func (d *DArray) IsMin() bool

+ func (d *DArray) Len() int

+ func (d *DArray) Next() (Datum, bool)

+ func (d *DArray) Prev() (Datum, bool)

+ func (d *DArray) ResolvedType() Type

+ func (d *DArray) Size() uintptr

+ func (d *DArray) TypeCheck(_ *SemaContext, _ Type) (TypedExpr, error)

+ func (d *DArray) Validate() error

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

+ func (node *DArray) String() string

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

+ type DBool bool

+ func GetBool(d Datum) (DBool, error)

+ func MakeDBool(d DBool) *DBool

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

+ func (*DBool) AmbiguousFormat() bool

+ func (*DBool) Next() (Datum, bool)

+ func (*DBool) Prev() (Datum, bool)

+ func (*DBool) ResolvedType() Type

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

+ func (d *DBool) Format(buf *bytes.Buffer, f FmtFlags)

+ func (d *DBool) IsMax() bool

+ func (d *DBool) IsMin() bool

+ func (d *DBool) Size() uintptr

+ func (d *DBool) TypeCheck(_ *SemaContext, _ Type) (TypedExpr, error)

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

+ func (node *DBool) String() string

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

+ type DBytes string

+ func NewDBytes(d DBytes) *DBytes

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

+ func (*DBytes) AmbiguousFormat() bool

+ func (*DBytes) IsMax() bool

+ func (*DBytes) ResolvedType() Type

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

+ func (d *DBytes) Format(buf *bytes.Buffer, f FmtFlags)

+ func (d *DBytes) IsMin() bool

+ func (d *DBytes) Next() (Datum, bool)

+ func (d *DBytes) Prev() (Datum, bool)

+ func (d *DBytes) Size() uintptr

+ func (d *DBytes) TypeCheck(_ *SemaContext, _ Type) (TypedExpr, error)

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

+ func (node *DBytes) String() string

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

+ type DCollatedString struct

+ Contents string

+ Key []byte

+ Locale string

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

+ func (*DCollatedString) AmbiguousFormat() bool

+ func (*DCollatedString) IsMax() bool

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

+ func (d *DCollatedString) Format(buf *bytes.Buffer, f FmtFlags)

+ func (d *DCollatedString) IsComposite() bool

+ func (d *DCollatedString) IsMin() bool

+ func (d *DCollatedString) Next() (Datum, bool)

+ func (d *DCollatedString) Prev() (Datum, bool)

+ func (d *DCollatedString) ResolvedType() Type

+ func (d *DCollatedString) Size() uintptr

+ func (d *DCollatedString) TypeCheck(_ *SemaContext, _ Type) (TypedExpr, error)

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

+ func (node *DCollatedString) String() string

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

+ type DDate int64

+ func NewDDate(d DDate) *DDate

+ func NewDDateFromTime(t time.Time, loc *time.Location) *DDate

+ func ParseDDate(s string, loc *time.Location) (*DDate, error)

+ func (*DDate) AmbiguousFormat() bool

+ func (*DDate) ResolvedType() Type

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

+ func (d *DDate) Format(buf *bytes.Buffer, f FmtFlags)

+ func (d *DDate) IsMax() bool

+ func (d *DDate) IsMin() bool

+ func (d *DDate) Next() (Datum, bool)

+ func (d *DDate) Prev() (Datum, bool)

+ func (d *DDate) Size() uintptr

+ func (d *DDate) TypeCheck(_ *SemaContext, _ Type) (TypedExpr, error)

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

+ func (node *DDate) String() string

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

+ type DDecimal struct

+ var DecimalOne DDecimal

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

+ func TimestampToDecimal(ts hlc.Timestamp) *DDecimal

+ func (*DDecimal) AmbiguousFormat() bool

+ func (*DDecimal) IsMax() bool

+ func (*DDecimal) IsMin() bool

+ func (*DDecimal) ResolvedType() Type

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

+ func (d *DDecimal) Format(buf *bytes.Buffer, f FmtFlags)

+ func (d *DDecimal) IsComposite() bool

+ func (d *DDecimal) Next() (Datum, bool)

+ func (d *DDecimal) Prev() (Datum, bool)

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

+ func (d *DDecimal) Size() uintptr

+ func (d *DDecimal) TypeCheck(_ *SemaContext, _ Type) (TypedExpr, error)

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

+ func (node *DDecimal) String() string

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

+ type DFloat float64

+ func NewDFloat(d DFloat) *DFloat

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

+ func (*DFloat) AmbiguousFormat() bool

+ func (*DFloat) ResolvedType() Type

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

+ func (d *DFloat) Format(buf *bytes.Buffer, f FmtFlags)

+ func (d *DFloat) IsComposite() bool

+ func (d *DFloat) IsMax() bool

+ func (d *DFloat) IsMin() bool

+ func (d *DFloat) Next() (Datum, bool)

+ func (d *DFloat) Prev() (Datum, bool)

+ func (d *DFloat) Size() uintptr

+ func (d *DFloat) TypeCheck(_ *SemaContext, _ Type) (TypedExpr, error)

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

+ func (node *DFloat) String() string

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

+ type DInt int64

+ func AsDInt(e Expr) (DInt, bool)

+ func GenerateUniqueInt(nodeID roachpb.NodeID) DInt

+ func MustBeDInt(e Expr) DInt

+ func NewDInt(d DInt) *DInt

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

+ func (*DInt) AmbiguousFormat() bool

+ func (*DInt) ResolvedType() Type

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

+ func (d *DInt) Format(buf *bytes.Buffer, f FmtFlags)

+ func (d *DInt) IsMax() bool

+ func (d *DInt) IsMin() bool

+ func (d *DInt) Next() (Datum, bool)

+ func (d *DInt) Prev() (Datum, bool)

+ func (d *DInt) Size() uintptr

+ func (d *DInt) TypeCheck(_ *SemaContext, _ Type) (TypedExpr, error)

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

+ func (node *DInt) String() string

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

+ type DInterval struct

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

+ func ParseDIntervalWithField(s string, field durationField) (*DInterval, error)

+ func (*DInterval) AmbiguousFormat() bool

+ func (*DInterval) ResolvedType() Type

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

+ func (d *DInterval) Format(buf *bytes.Buffer, f FmtFlags)

+ func (d *DInterval) IsMax() bool

+ func (d *DInterval) IsMin() bool

+ func (d *DInterval) Next() (Datum, bool)

+ func (d *DInterval) Prev() (Datum, bool)

+ func (d *DInterval) Size() uintptr

+ func (d *DInterval) TypeCheck(_ *SemaContext, _ Type) (TypedExpr, error)

+ func (d *DInterval) ValueAsString() string

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

+ func (node *DInterval) String() string

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

+ type DOid struct

+ func MakeDOid(d DInt) DOid

+ func NewDOid(d DInt) *DOid

+ func (*DOid) AmbiguousFormat() bool

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

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

+ func (d *DOid) Format(buf *bytes.Buffer, f FmtFlags)

+ func (d *DOid) IsMax() bool

+ func (d *DOid) IsMin() bool

+ func (d *DOid) Next() (Datum, bool)

+ func (d *DOid) Prev() (Datum, bool)

+ func (d *DOid) ResolvedType() Type

+ func (d *DOid) Size() uintptr

+ func (d *DOid) TypeCheck(_ *SemaContext, _ Type) (TypedExpr, error)

+ func (expr *DOid) Walk(_ Visitor) Expr

+ func (node *DOid) String() string

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

+ type DOidWrapper struct

+ Oid oid.Oid

+ Wrapped Datum

+ func (d *DOidWrapper) AmbiguousFormat() bool

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

+ func (d *DOidWrapper) Format(buf *bytes.Buffer, f FmtFlags)

+ func (d *DOidWrapper) IsMax() bool

+ func (d *DOidWrapper) IsMin() bool

+ func (d *DOidWrapper) Next() (Datum, bool)

+ func (d *DOidWrapper) Prev() (Datum, bool)

+ func (d *DOidWrapper) ResolvedType() Type

+ func (d *DOidWrapper) Size() uintptr

+ func (d *DOidWrapper) TypeCheck(_ *SemaContext, _ Type) (TypedExpr, error)

+ func (expr *DOidWrapper) Walk(_ Visitor) Expr

+ func (node *DOidWrapper) String() string

+ func (t *DOidWrapper) Eval(_ *EvalContext) (Datum, error)

+ type DString string

+ func AsDString(e Expr) (DString, bool)

+ func MustBeDString(e Expr) DString

+ func NewDString(d string) *DString

+ func (*DString) AmbiguousFormat() bool

+ func (*DString) IsMax() bool

+ func (*DString) ResolvedType() Type

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

+ func (d *DString) Format(buf *bytes.Buffer, f FmtFlags)

+ func (d *DString) IsMin() bool

+ func (d *DString) Next() (Datum, bool)

+ func (d *DString) Prev() (Datum, bool)

+ func (d *DString) Size() uintptr

+ func (d *DString) TypeCheck(_ *SemaContext, _ Type) (TypedExpr, error)

+ func (expr *DString) Walk(_ Visitor) Expr

+ func (node *DString) String() string

+ func (t *DString) Eval(_ *EvalContext) (Datum, error)

+ type DTable struct

+ func EmptyDTable() *DTable

+ func (*DTable) AmbiguousFormat() bool

+ func (*DTable) IsMax() bool

+ func (*DTable) IsMin() bool

+ func (*DTable) Next() (Datum, bool)

+ func (*DTable) Prev() (Datum, bool)

+ func (*DTable) Size() uintptr

+ func (d *DTable) TypeCheck(_ *SemaContext, _ Type) (TypedExpr, error)

+ func (expr *DTable) Walk(_ Visitor) Expr

+ func (node *DTable) String() string

+ func (t *DTable) Compare(ctx *EvalContext, other Datum) int

+ func (t *DTable) Eval(_ *EvalContext) (Datum, error)

+ func (t *DTable) Format(buf *bytes.Buffer, _ FmtFlags)

+ func (t *DTable) ResolvedType() Type

+ type DTimestamp struct

+ func MakeDTimestamp(t time.Time, precision time.Duration) *DTimestamp

+ func ParseDTimestamp(s string, precision time.Duration) (*DTimestamp, error)

+ func (*DTimestamp) AmbiguousFormat() bool

+ func (*DTimestamp) ResolvedType() Type

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

+ func (d *DTimestamp) Format(buf *bytes.Buffer, f FmtFlags)

+ func (d *DTimestamp) IsMax() bool

+ func (d *DTimestamp) IsMin() bool

+ func (d *DTimestamp) Next() (Datum, bool)

+ func (d *DTimestamp) Prev() (Datum, bool)

+ func (d *DTimestamp) Size() uintptr

+ func (d *DTimestamp) TypeCheck(_ *SemaContext, _ Type) (TypedExpr, error)

+ func (expr *DTimestamp) Walk(_ Visitor) Expr

+ func (node *DTimestamp) String() string

+ func (t *DTimestamp) Eval(_ *EvalContext) (Datum, error)

+ type DTimestampTZ struct

+ func MakeDTimestampTZ(t time.Time, precision time.Duration) *DTimestampTZ

+ func MakeDTimestampTZFromDate(loc *time.Location, d *DDate) *DTimestampTZ

+ func ParseDTimestampTZ(s string, loc *time.Location, precision time.Duration) (*DTimestampTZ, error)

+ func (*DTimestampTZ) AmbiguousFormat() bool

+ func (*DTimestampTZ) ResolvedType() Type

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

+ func (d *DTimestampTZ) Format(buf *bytes.Buffer, f FmtFlags)

+ func (d *DTimestampTZ) IsMax() bool

+ func (d *DTimestampTZ) IsMin() bool

+ func (d *DTimestampTZ) Next() (Datum, bool)

+ func (d *DTimestampTZ) Prev() (Datum, bool)

+ func (d *DTimestampTZ) Size() uintptr

+ func (d *DTimestampTZ) TypeCheck(_ *SemaContext, _ Type) (TypedExpr, error)

+ func (expr *DTimestampTZ) Walk(_ Visitor) Expr

+ func (node *DTimestampTZ) String() string

+ func (t *DTimestampTZ) Eval(_ *EvalContext) (Datum, error)

+ type DTuple struct

+ D Datums

+ Sorted bool

+ func NewDTuple(d ...Datum) *DTuple

+ func NewDTupleWithCap(c int) *DTuple

+ func NewDTupleWithLen(l int) *DTuple

+ func (*DTuple) AmbiguousFormat() bool

+ func (d *DTuple) AssertSorted()

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

+ func (d *DTuple) Format(buf *bytes.Buffer, f FmtFlags)

+ func (d *DTuple) IsMax() bool

+ func (d *DTuple) IsMin() bool

+ func (d *DTuple) Next() (Datum, bool)

+ func (d *DTuple) Normalize(ctx *EvalContext)

+ func (d *DTuple) Prev() (Datum, bool)

+ func (d *DTuple) ResolvedType() Type

+ func (d *DTuple) SearchSorted(ctx *EvalContext, target Datum) (int, bool)

+ func (d *DTuple) SetSorted() *DTuple

+ func (d *DTuple) Size() uintptr

+ func (d *DTuple) SortedDifference(ctx *EvalContext, other *DTuple) *DTuple

+ func (d *DTuple) TypeCheck(_ *SemaContext, _ Type) (TypedExpr, error)

+ func (expr *DTuple) Walk(_ Visitor) Expr

+ func (node *DTuple) String() string

+ func (t *DTuple) Eval(_ *EvalContext) (Datum, error)

+ type DUuid struct

+ func NewDUuid(d DUuid) *DUuid

+ func ParseDUuidFromBytes(b []byte) (*DUuid, error)

+ func ParseDUuidFromString(s string) (*DUuid, error)

+ func (*DUuid) AmbiguousFormat() bool

+ func (*DUuid) ResolvedType() Type

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

+ func (d *DUuid) Format(buf *bytes.Buffer, f FmtFlags)

+ func (d *DUuid) IsMax() bool

+ func (d *DUuid) IsMin() bool

+ func (d *DUuid) Next() (Datum, bool)

+ func (d *DUuid) Prev() (Datum, bool)

+ func (d *DUuid) Size() uintptr

+ func (d *DUuid) TypeCheck(_ *SemaContext, _ Type) (TypedExpr, error)

+ func (expr *DUuid) Walk(_ Visitor) Expr

+ func (node *DUuid) String() string

+ func (t *DUuid) Eval(_ *EvalContext) (Datum, error)

+ type DatabaseQualifiable interface

+ QualifyWithDatabase func(database string) error

+ type DateColType struct

+ func (node *DateColType) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *DateColType) String() string

+ type Datum interface

+ AmbiguousFormat func() bool

+ Compare func(ctx *EvalContext, other Datum) int

+ IsMax func() bool

+ IsMin func() bool

+ Next func() (Datum, bool)

+ Prev func() (Datum, bool)

+ Size func() uintptr

+ func NewDIntVectorFromDArray(d *DArray) Datum

+ func NewDName(d string) Datum

+ func NewDNameFromDString(d *DString) Datum

+ func ParseStringAs(t Type, s string, evalCtx *EvalContext) (Datum, error)

+ func UnwrapDatum(d Datum) Datum

+ type Datums []Datum

+ func (d Datums) Format(buf *bytes.Buffer, f FmtFlags)

+ func (d Datums) Len() int

+ func (d Datums) Reverse()

+ func (node *Datums) String() string

+ type Deallocate struct

+ Name Name

+ func (*Deallocate) StatementType() StatementType

+ func (n *Deallocate) StatementTag() string

+ func (n *Deallocate) String() string

+ func (node *Deallocate) Format(buf *bytes.Buffer, f FmtFlags)

+ type DecimalColType struct

+ Name string

+ Prec int

+ Scale int

+ func (node *DecimalColType) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *DecimalColType) String() string

+ type DefaultVal struct

+ func (DefaultVal) ResolvedType() Type

+ func (expr DefaultVal) Eval(ctx *EvalContext) (Datum, error)

+ func (expr DefaultVal) TypeCheck(_ *SemaContext, desired Type) (TypedExpr, error)

+ func (expr DefaultVal) Walk(_ Visitor) Expr

+ func (node DefaultVal) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node DefaultVal) String() string

+ type Delete struct

+ Limit *Limit

+ Returning ReturningClause

+ Table TableExpr

+ Where *Where

+ func (*Delete) StatementTag() string

+ func (n *Delete) StatementType() StatementType

+ func (n *Delete) String() string

+ func (node *Delete) Format(buf *bytes.Buffer, f FmtFlags)

+ func (stmt *Delete) CopyNode() *Delete

+ func (stmt *Delete) WalkStmt(v Visitor) Statement

+ type Direction int

+ const Ascending

+ const DefaultDirection

+ const Descending

+ func (d Direction) String() string

+ type Discard struct

+ Mode DiscardMode

+ func (*Discard) StatementTag() string

+ func (*Discard) StatementType() StatementType

+ func (node *Discard) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *Discard) String() string

+ type DiscardMode int

+ const DiscardModeAll

+ type DropBehavior int

+ const DropCascade

+ const DropDefault

+ const DropRestrict

+ func (d DropBehavior) String() string

+ type DropDatabase struct

+ DropBehavior DropBehavior

+ IfExists bool

+ Name Name

+ func (*DropDatabase) StatementTag() string

+ func (*DropDatabase) StatementType() StatementType

+ func (n *DropDatabase) String() string

+ func (node *DropDatabase) Format(buf *bytes.Buffer, f FmtFlags)

+ type DropIndex struct

+ DropBehavior DropBehavior

+ IfExists bool

+ IndexList TableNameWithIndexList

+ func (*DropIndex) StatementTag() string

+ func (*DropIndex) StatementType() StatementType

+ func (n *DropIndex) String() string

+ func (node *DropIndex) Format(buf *bytes.Buffer, f FmtFlags)

+ type DropTable struct

+ DropBehavior DropBehavior

+ IfExists bool

+ Names TableNameReferences

+ func (*DropTable) StatementTag() string

+ func (*DropTable) StatementType() StatementType

+ func (n *DropTable) String() string

+ func (node *DropTable) Format(buf *bytes.Buffer, f FmtFlags)

+ type DropUser struct

+ IfExists bool

+ Names NameList

+ func (*DropUser) StatementTag() string

+ func (*DropUser) StatementType() StatementType

+ func (n *DropUser) String() string

+ func (node *DropUser) Format(buf *bytes.Buffer, f FmtFlags)

+ type DropView struct

+ DropBehavior DropBehavior

+ IfExists bool

+ Names TableNameReferences

+ func (*DropView) StatementTag() string

+ func (*DropView) StatementType() StatementType

+ func (n *DropView) String() string

+ func (node *DropView) Format(buf *bytes.Buffer, f FmtFlags)

+ type EvalContext struct

+ ActiveMemAcc *mon.BoundAccount

+ ClusterID uuid.UUID

+ Ctx contextHolder

+ Database string

+ Location **time.Location

+ Mon *mon.BytesMonitor

+ NodeID roachpb.NodeID

+ Planner EvalPlanner

+ PrepareOnly bool

+ ReCache *RegexpCache

+ SearchPath SearchPath

+ SkipNormalize bool

+ Txn *client.Txn

+ User string

+ func MakeTestingEvalContext() EvalContext

+ func NewTestingEvalContext() *EvalContext

+ func (ctx *EvalContext) GetClusterTimestamp() *DDecimal

+ func (ctx *EvalContext) GetClusterTimestampRaw() hlc.Timestamp

+ func (ctx *EvalContext) GetLocation() *time.Location

+ func (ctx *EvalContext) GetStmtTimestamp() time.Time

+ func (ctx *EvalContext) GetTxnTimestamp(precision time.Duration) *DTimestampTZ

+ func (ctx *EvalContext) GetTxnTimestampNoZone(precision time.Duration) *DTimestamp

+ func (ctx *EvalContext) GetTxnTimestampRaw() time.Time

+ func (ctx *EvalContext) NormalizeExpr(typedExpr TypedExpr) (TypedExpr, error)

+ func (ctx *EvalContext) SetClusterTimestamp(ts hlc.Timestamp)

+ func (ctx *EvalContext) SetStmtTimestamp(ts time.Time)

+ func (ctx *EvalContext) SetTxnTimestamp(ts time.Time)

+ func (ctx *EvalContext) Stop(c context.Context)

+ type EvalPlanner interface

+ QualifyWithDatabase func(ctx context.Context, t *NormalizableTableName) (*TableName, error)

+ QueryRow func(ctx context.Context, sql string, args ...interface{}) (Datums, error)

+ type Execute struct

+ Name Name

+ Params Exprs

+ func (*Execute) StatementTag() string

+ func (*Execute) StatementType() StatementType

+ func (n *Execute) String() string

+ func (node *Execute) Format(buf *bytes.Buffer, f FmtFlags)

+ type ExistsExpr struct

+ Subquery Expr

+ func (expr *ExistsExpr) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

+ func (expr *ExistsExpr) Walk(v Visitor) Expr

+ func (node *ExistsExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *ExistsExpr) String() string

+ func (t *ExistsExpr) Eval(ctx *EvalContext) (Datum, error)

+ func (ta ExistsExpr) ResolvedType() Type

+ type Explain struct

+ Options []string

+ Statement Statement

+ func (*Explain) StatementTag() string

+ func (*Explain) StatementType() StatementType

+ func (n *Explain) String() string

+ func (node *Explain) Format(buf *bytes.Buffer, f FmtFlags)

+ func (stmt *Explain) CopyNode() *Explain

+ func (stmt *Explain) WalkStmt(v Visitor) Statement

+ type Expr interface

+ TypeCheck func(ctx *SemaContext, desired Type) (TypedExpr, error)

+ Walk func(Visitor) Expr

+ func ParseExpr(sql string) (Expr, error)

+ func SimpleVisit(expr Expr, preFn SimpleVisitFn) (Expr, error)

+ func StripParens(expr Expr) Expr

+ func WalkExpr(v Visitor, expr Expr) (newExpr Expr, changed bool)

+ type Exprs []Expr

+ func ParseExprs(sql []string) (Exprs, error)

+ func (node Exprs) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node Exprs) String() string

+ type FamilyTableDef struct

+ Columns NameList

+ Name Name

+ func (node *FamilyTableDef) Format(buf *bytes.Buffer, f FmtFlags)

+ type FloatColType struct

+ Name string

+ Prec int

+ PrecSpecified bool

+ Width int

+ func NewFloatColType(prec int, precSpecified bool) *FloatColType

+ func (node *FloatColType) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *FloatColType) String() string

+ type FmtFlags *fmtFlags

+ var FmtAnonymize FmtFlags = &fmtFlags{ ... }

+ var FmtArrays FmtFlags = &fmtFlags{ ... }

+ var FmtBareIdentifiers FmtFlags = &fmtFlags{ ... }

+ var FmtBareStrings FmtFlags = &fmtFlags{ ... }

+ var FmtCheckEquivalence FmtFlags = &fmtFlags{ ... }

+ var FmtHideConstants FmtFlags = &fmtFlags{ ... }

+ var FmtParsable FmtFlags = &fmtFlags{ ... }

+ var FmtShowTypes FmtFlags = &fmtFlags{ ... }

+ var FmtSimple FmtFlags = &fmtFlags{}

+ var FmtSimpleQualified FmtFlags = &fmtFlags{ ... }

+ var FmtSimpleWithPasswords FmtFlags = &fmtFlags{ ... }

+ func FmtExpr(base FmtFlags, showTypes bool, symbolicVars bool, showTableAliases bool) FmtFlags

+ func FmtIndexedVarFormat(base FmtFlags, ...) FmtFlags

+ func FmtReformatTableNames(base FmtFlags, fn func(*NormalizableTableName, *bytes.Buffer, FmtFlags)) FmtFlags

+ func FmtStarDatumFormat(base FmtFlags, fn func(buf *bytes.Buffer, f FmtFlags)) FmtFlags

+ func StripTypeFormatting(f FmtFlags) FmtFlags

+ type ForeignKeyConstraintTableDef struct

+ FromCols NameList

+ Name Name

+ Table NormalizableTableName

+ ToCols NameList

+ func (node *ForeignKeyConstraintTableDef) Format(buf *bytes.Buffer, f FmtFlags)

+ type From struct

+ AsOf AsOfClause

+ Tables TableExprs

+ func (node *From) Format(buf *bytes.Buffer, f FmtFlags)

+ type FuncExpr struct

+ Exprs Exprs

+ Filter Expr

+ Func ResolvableFunctionReference

+ Type funcType

+ WindowDef *WindowDef

+ func (expr *FuncExpr) CopyNode() *FuncExpr

+ func (expr *FuncExpr) Eval(ctx *EvalContext) (Datum, error)

+ func (expr *FuncExpr) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

+ func (expr *FuncExpr) Walk(v Visitor) Expr

+ func (node *FuncExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *FuncExpr) GetAggregateConstructor() func(*EvalContext) AggregateFunc

+ func (node *FuncExpr) GetWindowConstructor() func(*EvalContext) WindowFunc

+ func (node *FuncExpr) IsDistSQLBlacklist() bool

+ func (node *FuncExpr) IsImpure() bool

+ func (node *FuncExpr) IsWindowFunctionApplication() bool

+ func (node *FuncExpr) String() string

+ func (ta FuncExpr) ResolvedType() Type

+ type FunctionClass int

+ const AggregateClass

+ const GeneratorClass

+ const NormalClass

+ const WindowClass

+ type FunctionDefinition struct

+ Definition []overloadImpl

+ HasOverloadsNeedingRepeatedEvaluation bool

+ Name string

+ func (fd *FunctionDefinition) Format(buf *bytes.Buffer, f FmtFlags)

+ func (fd *FunctionDefinition) String() string

+ type FunctionReference interface

+ type Grant struct

+ Grantees NameList

+ Privileges privilege.List

+ Targets TargetList

+ func (*Grant) StatementTag() string

+ func (*Grant) StatementType() StatementType

+ func (n *Grant) String() string

+ func (node *Grant) Format(buf *bytes.Buffer, f FmtFlags)

+ type GroupBy []Expr

+ func (node GroupBy) Format(buf *bytes.Buffer, f FmtFlags)

+ type HelpMessage struct

+ Command string

+ Function string

+ func (h *HelpMessage) Format(w io.Writer)

+ func (h *HelpMessage) String() string

+ type HelpMessageBody struct

+ Category string

+ SeeAlso string

+ ShortDescription string

+ Text string

+ type HiddenFromShowQueries interface

+ type HiddenFromStats interface

+ type HomogeneousType struct

+ func (HomogeneousType) Length() int

+ func (HomogeneousType) String() string

+ func (HomogeneousType) Types() []Type

+ type ID uint32

+ type IfExpr struct

+ Cond Expr

+ Else Expr

+ True Expr

+ func (expr *IfExpr) Eval(ctx *EvalContext) (Datum, error)

+ func (expr *IfExpr) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

+ func (expr *IfExpr) Walk(v Visitor) Expr

+ func (node *IfExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *IfExpr) String() string

+ func (node *IfExpr) TypedCondExpr() TypedExpr

+ func (node *IfExpr) TypedElseExpr() TypedExpr

+ func (node *IfExpr) TypedTrueExpr() TypedExpr

+ func (ta IfExpr) ResolvedType() Type

+ type Import struct

+ CreateDefs TableDefs

+ CreateFile Expr

+ FileFormat string

+ Files Exprs

+ Options KVOptions

+ Table UnresolvedName

+ func (*Import) StatementTag() string

+ func (n *Import) StatementType() StatementType

+ func (n *Import) String() string

+ func (node *Import) Format(buf *bytes.Buffer, f FmtFlags)

+ func (stmt *Import) CopyNode() *Import

+ func (stmt *Import) WalkStmt(v Visitor) Statement

+ type IndependentFromParallelizedPriors interface

+ type IndexElem struct

+ Column Name

+ Direction Direction

+ func (node IndexElem) Format(buf *bytes.Buffer, f FmtFlags)

+ type IndexElemList []IndexElem

+ func (l IndexElemList) Format(buf *bytes.Buffer, f FmtFlags)

+ type IndexHints struct

+ Index Name

+ IndexID IndexID

+ NoIndexJoin bool

+ func (n *IndexHints) Format(buf *bytes.Buffer, f FmtFlags)

+ type IndexID uint32

+ type IndexTableDef struct

+ Columns IndexElemList

+ Interleave *InterleaveDef

+ Name Name

+ Storing NameList

+ func (node *IndexTableDef) Format(buf *bytes.Buffer, f FmtFlags)

+ type IndexedRow struct

+ Idx int

+ Row Datums

+ type IndexedVar struct

+ Idx int

+ func NewIndexedVar(r int) *IndexedVar

+ func NewOrdinalReference(r int) *IndexedVar

+ func (*IndexedVar) Variable()

+ func (node *IndexedVar) String() string

+ func (v *IndexedVar) Eval(ctx *EvalContext) (Datum, error)

+ func (v *IndexedVar) Format(buf *bytes.Buffer, f FmtFlags)

+ func (v *IndexedVar) ResolvedType() Type

+ func (v *IndexedVar) TypeCheck(_ *SemaContext, desired Type) (TypedExpr, error)

+ func (v *IndexedVar) Walk(_ Visitor) Expr

+ type IndexedVarContainer interface

+ IndexedVarEval func(idx int, ctx *EvalContext) (Datum, error)

+ IndexedVarFormat func(buf *bytes.Buffer, f FmtFlags, idx int)

+ IndexedVarResolvedType func(idx int) Type

+ type IndexedVarHelper struct

+ func MakeIndexedVarHelper(container IndexedVarContainer, numVars int) IndexedVarHelper

+ func (*IndexedVarHelper) VisitPost(expr Expr) Expr

+ func (h *IndexedVarHelper) AppendSlot() int

+ func (h *IndexedVarHelper) BindIfUnbound(ivar *IndexedVar) (*IndexedVar, error)

+ func (h *IndexedVarHelper) GetIndexedVars() []IndexedVar

+ func (h *IndexedVarHelper) IndexedVar(idx int) *IndexedVar

+ func (h *IndexedVarHelper) IndexedVarUsed(idx int) bool

+ func (h *IndexedVarHelper) NumVars() int

+ func (h *IndexedVarHelper) Rebind(expr TypedExpr, alsoReset, normalizeToNonNil bool) TypedExpr

+ func (h *IndexedVarHelper) Reset()

+ func (h *IndexedVarHelper) VisitPre(expr Expr) (recurse bool, newExpr Expr)

+ type IndirectionExpr struct

+ Expr Expr

+ Indirection ArraySubscripts

+ func (expr *IndirectionExpr) CopyNode() *IndirectionExpr

+ func (expr *IndirectionExpr) Eval(ctx *EvalContext) (Datum, error)

+ func (expr *IndirectionExpr) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

+ func (expr *IndirectionExpr) Walk(v Visitor) Expr

+ func (node *IndirectionExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *IndirectionExpr) String() string

+ func (ta IndirectionExpr) ResolvedType() Type

+ type Insert struct

+ Columns UnresolvedNames

+ OnConflict *OnConflict

+ Returning ReturningClause

+ Rows *Select

+ Table TableExpr

+ func (*Insert) StatementTag() string

+ func (n *Insert) StatementType() StatementType

+ func (n *Insert) String() string

+ func (node *Insert) DefaultValues() bool

+ func (node *Insert) Format(buf *bytes.Buffer, f FmtFlags)

+ func (stmt *Insert) CopyNode() *Insert

+ func (stmt *Insert) WalkStmt(v Visitor) Statement

+ type IntColType struct

+ ImplicitWidth bool

+ Name string

+ Width int

+ func (node *IntColType) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *IntColType) IsSerial() bool

+ func (node *IntColType) String() string

+ type InterleaveDef struct

+ DropBehavior DropBehavior

+ Fields NameList

+ Parent *NormalizableTableName

+ func (node *InterleaveDef) Format(buf *bytes.Buffer, f FmtFlags)

+ type IntervalColType struct

+ func (node *IntervalColType) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *IntervalColType) String() string

+ type IsAggregateVisitor struct

+ Aggregated bool

+ func (*IsAggregateVisitor) VisitPost(expr Expr) Expr

+ func (v *IsAggregateVisitor) Reset()

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

+ type IsOfTypeExpr struct

+ Expr Expr

+ Not bool

+ Types []ColumnType

+ func (expr *IsOfTypeExpr) Eval(ctx *EvalContext) (Datum, error)

+ func (expr *IsOfTypeExpr) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

+ func (expr *IsOfTypeExpr) Walk(v Visitor) Expr

+ func (node *IsOfTypeExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *IsOfTypeExpr) String() string

+ func (ta IsOfTypeExpr) ResolvedType() Type

+ type IsolationLevel int

+ const SerializableIsolation

+ const SnapshotIsolation

+ const UnspecifiedIsolation

+ func (i IsolationLevel) String() string

+ type JoinCond interface

+ type JoinTableExpr struct

+ Cond JoinCond

+ Join string

+ Left TableExpr

+ Right TableExpr

+ func (node *JoinTableExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *JoinTableExpr) String() string

+ type KVOption struct

+ Key Name

+ Value Expr

+ type KVOptions []KVOption

+ func (o KVOptions) Format(buf *bytes.Buffer, f FmtFlags)

+ type Limit struct

+ Count Expr

+ Offset Expr

+ func (node *Limit) Format(buf *bytes.Buffer, f FmtFlags)

+ type MaxAggregate struct

+ func (a *MaxAggregate) Add(_ context.Context, datum Datum) error

+ func (a *MaxAggregate) Close(context.Context)

+ func (a *MaxAggregate) Result() (Datum, error)

+ type MinAggregate struct

+ func (a *MinAggregate) Add(_ context.Context, datum Datum) error

+ func (a *MinAggregate) Close(context.Context)

+ func (a *MinAggregate) Result() (Datum, error)

+ type MultipleResultsError struct

+ SQL string

+ func (e *MultipleResultsError) Error() string

+ type Name string

+ func (n Name) Format(buf *bytes.Buffer, f FmtFlags)

+ func (n Name) Normalize() string

+ func (node Name) String() string

+ type NameColType struct

+ func (node *NameColType) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *NameColType) String() string

+ type NameList []Name

+ func (l NameList) Format(buf *bytes.Buffer, f FmtFlags)

+ func (l NameList) ToStrings() []string

+ func (list NameList) String() string

+ type NamePart interface

+ type NameParts []NamePart

+ func (l NameParts) Format(buf *bytes.Buffer, f FmtFlags)

+ type NamedColumnQualification struct

+ Name Name

+ Qualification ColumnQualification

+ type NaturalJoinCond struct

+ func (NaturalJoinCond) Format(buf *bytes.Buffer, _ FmtFlags)

+ type NoReturningClause struct

+ func (*NoReturningClause) Format(buf *bytes.Buffer, f FmtFlags)

+ type NodeFormatter interface

+ Format func(buf *bytes.Buffer, flags FmtFlags)

+ type NormalizableTableName struct

+ func (nt *NormalizableTableName) Format(buf *bytes.Buffer, f FmtFlags)

+ func (nt *NormalizableTableName) Normalize() (*TableName, error)

+ func (nt *NormalizableTableName) NormalizeWithDatabaseName(database string) (*TableName, error)

+ func (nt *NormalizableTableName) String() string

+ func (nt *NormalizableTableName) TableName() *TableName

+ type NotExpr struct

+ Expr Expr

+ func NewTypedNotExpr(expr TypedExpr) *NotExpr

+ func (expr *NotExpr) Eval(ctx *EvalContext) (Datum, error)

+ func (expr *NotExpr) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

+ func (expr *NotExpr) Walk(v Visitor) Expr

+ func (node *NotExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *NotExpr) String() string

+ func (node *NotExpr) TypedInnerExpr() TypedExpr

+ func (ta NotExpr) ResolvedType() Type

+ type NotNullConstraint struct

+ type NullConstraint struct

+ type NullIfExpr struct

+ Expr1 Expr

+ Expr2 Expr

+ func (expr *NullIfExpr) Eval(ctx *EvalContext) (Datum, error)

+ func (expr *NullIfExpr) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

+ func (expr *NullIfExpr) Walk(v Visitor) Expr

+ func (node *NullIfExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *NullIfExpr) String() string

+ func (ta NullIfExpr) ResolvedType() Type

+ type Nullability int

+ const NotNull

+ const Null

+ const SilentNull

+ type NumVal struct

+ OrigString string

+ func (expr *NumVal) AsInt64() (int64, error)

+ func (expr *NumVal) AvailableTypes() []Type

+ func (expr *NumVal) DesirableTypes() []Type

+ func (expr *NumVal) Format(buf *bytes.Buffer, f FmtFlags)

+ func (expr *NumVal) ResolveAsType(ctx *SemaContext, typ Type) (Datum, error)

+ func (expr *NumVal) ShouldBeInt64() bool

+ func (expr *NumVal) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

+ func (expr *NumVal) Walk(_ Visitor) Expr

+ func (node *NumVal) String() string

+ type OidColType struct

+ Name string

+ func (node *OidColType) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *OidColType) String() string

+ type OnConflict struct

+ Columns NameList

+ DoNothing bool

+ Exprs UpdateExprs

+ Where *Where

+ func (oc *OnConflict) IsUpsertAlias() bool

+ type OnJoinCond struct

+ Expr Expr

+ func (node *OnJoinCond) Format(buf *bytes.Buffer, f FmtFlags)

+ type OrExpr struct

+ Left Expr

+ Right Expr

+ func NewTypedOrExpr(left, right TypedExpr) *OrExpr

+ func (expr *OrExpr) Eval(ctx *EvalContext) (Datum, error)

+ func (expr *OrExpr) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

+ func (expr *OrExpr) Walk(v Visitor) Expr

+ func (node *OrExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *OrExpr) String() string

+ func (node *OrExpr) TypedLeft() TypedExpr

+ func (node *OrExpr) TypedRight() TypedExpr

+ func (ta OrExpr) ResolvedType() Type

+ type Order struct

+ Direction Direction

+ Expr Expr

+ Index Name

+ OrderType OrderType

+ Table NormalizableTableName

+ func (node *Order) Format(buf *bytes.Buffer, f FmtFlags)

+ type OrderBy []*Order

+ func (node OrderBy) Format(buf *bytes.Buffer, f FmtFlags)

+ type OrderType int

+ const OrderByColumn

+ const OrderByIndex

+ type ParenExpr struct

+ Expr Expr

+ func (expr *ParenExpr) Eval(ctx *EvalContext) (Datum, error)

+ func (expr *ParenExpr) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

+ func (expr *ParenExpr) Walk(v Visitor) Expr

+ func (node *ParenExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *ParenExpr) String() string

+ func (node *ParenExpr) TypedInnerExpr() TypedExpr

+ func (ta ParenExpr) ResolvedType() Type

+ type ParenSelect struct

+ Select *Select

+ func (*ParenSelect) StatementTag() string

+ func (*ParenSelect) StatementType() StatementType

+ func (n *ParenSelect) String() string

+ func (node *ParenSelect) Format(buf *bytes.Buffer, f FmtFlags)

+ func (stmt *ParenSelect) WalkStmt(v Visitor) Statement

+ type ParenTableExpr struct

+ Expr TableExpr

+ func (node *ParenTableExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *ParenTableExpr) String() string

+ type Parser struct

+ func (p *Parser) AggregateInExpr(expr Expr, searchPath SearchPath) bool

+ func (p *Parser) AssertNoAggregationOrWindowing(expr Expr, op string, searchPath SearchPath) error

+ func (p *Parser) IsAggregate(n *SelectClause, searchPath SearchPath) bool

+ func (p *Parser) NormalizeExpr(ctx *EvalContext, typedExpr TypedExpr) (TypedExpr, error)

+ func (p *Parser) Parse(sql string) (stmts StatementList, err error)

+ func (p *Parser) WindowFuncInExpr(expr Expr) bool

+ func (p *Parser) WindowFuncInExprs(exprs []TypedExpr) bool

+ type PauseJob struct

+ ID Expr

+ func (*PauseJob) StatementTag() string

+ func (*PauseJob) StatementType() StatementType

+ func (n *PauseJob) String() string

+ func (node *PauseJob) Format(buf *bytes.Buffer, f FmtFlags)

+ type Placeholder struct

+ Name string

+ func NewPlaceholder(name string) *Placeholder

+ func (*Placeholder) Variable()

+ func (expr *Placeholder) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

+ func (expr *Placeholder) Walk(_ Visitor) Expr

+ func (node *Placeholder) Eval(_ *EvalContext) (Datum, error)

+ func (node *Placeholder) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *Placeholder) ResolvedType() Type

+ func (node *Placeholder) String() string

+ type PlaceholderInfo struct

+ TypeHints PlaceholderTypes

+ Types PlaceholderTypes

+ Values QueryArguments

+ func MakePlaceholderInfo() PlaceholderInfo

+ func (p *PlaceholderInfo) AssertAllAssigned() error

+ func (p *PlaceholderInfo) Assign(src *PlaceholderInfo)

+ func (p *PlaceholderInfo) Clear()

+ func (p *PlaceholderInfo) FillUnassigned()

+ func (p *PlaceholderInfo) IsUnresolvedPlaceholder(expr Expr) bool

+ func (p *PlaceholderInfo) SetType(name string, typ Type) error

+ func (p *PlaceholderInfo) SetTypeHints(src PlaceholderTypes)

+ func (p *PlaceholderInfo) SetValue(name string, val Datum)

+ func (p *PlaceholderInfo) Type(name string, allowHints bool) (Type, bool)

+ func (p *PlaceholderInfo) Value(name string) (TypedExpr, bool)

+ type PlaceholderTypes map[string]Type

+ func (p PlaceholderTypes) ProcessPlaceholderAnnotations(stmt Statement) error

+ type Prepare struct

+ Name Name

+ Statement Statement

+ Types []ColumnType

+ func (*Prepare) StatementTag() string

+ func (*Prepare) StatementType() StatementType

+ func (n *Prepare) String() string

+ func (node *Prepare) Format(buf *bytes.Buffer, f FmtFlags)

+ type PrimaryKeyConstraint struct

+ type QueryArguments map[string]TypedExpr

+ type RangeCond struct

+ From Expr

+ Left Expr

+ Not bool

+ To Expr

+ func (expr *RangeCond) Eval(ctx *EvalContext) (Datum, error)

+ func (expr *RangeCond) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

+ func (expr *RangeCond) Walk(v Visitor) Expr

+ func (node *RangeCond) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *RangeCond) String() string

+ func (node *RangeCond) TypedFrom() TypedExpr

+ func (node *RangeCond) TypedLeft() TypedExpr

+ func (node *RangeCond) TypedTo() TypedExpr

+ func (ta RangeCond) ResolvedType() Type

+ type ReadWriteMode int

+ const ReadOnly

+ const ReadWrite

+ const UnspecifiedReadWriteMode

+ func (ro ReadWriteMode) String() string

+ type RegexpCache struct

+ func NewRegexpCache(size int) *RegexpCache

+ func (rc *RegexpCache) GetRegexp(key regexpCacheKey) (*regexp.Regexp, error)

+ func (rc *RegexpCache) Len() int

+ type ReleaseSavepoint struct

+ Savepoint string

+ func (*ReleaseSavepoint) StatementTag() string

+ func (*ReleaseSavepoint) StatementType() StatementType

+ func (n *ReleaseSavepoint) String() string

+ func (node *ReleaseSavepoint) Format(buf *bytes.Buffer, f FmtFlags)

+ type RenameColumn struct

+ IfExists bool

+ Name Name

+ NewName Name

+ Table NormalizableTableName

+ func (*RenameColumn) StatementTag() string

+ func (*RenameColumn) StatementType() StatementType

+ func (n *RenameColumn) String() string

+ func (node *RenameColumn) Format(buf *bytes.Buffer, f FmtFlags)

+ type RenameDatabase struct

+ Name Name

+ NewName Name

+ func (*RenameDatabase) StatementTag() string

+ func (*RenameDatabase) StatementType() StatementType

+ func (n *RenameDatabase) String() string

+ func (node *RenameDatabase) Format(buf *bytes.Buffer, f FmtFlags)

+ type RenameIndex struct

+ IfExists bool

+ Index *TableNameWithIndex

+ NewName Name

+ func (*RenameIndex) StatementTag() string

+ func (*RenameIndex) StatementType() StatementType

+ func (n *RenameIndex) String() string

+ func (node *RenameIndex) Format(buf *bytes.Buffer, f FmtFlags)

+ type RenameTable struct

+ IfExists bool

+ IsView bool

+ Name NormalizableTableName

+ NewName NormalizableTableName

+ func (*RenameTable) StatementType() StatementType

+ func (n *RenameTable) StatementTag() string

+ func (n *RenameTable) String() string

+ func (node *RenameTable) Format(buf *bytes.Buffer, f FmtFlags)

+ type ResolvableFunctionReference struct

+ func (fn *ResolvableFunctionReference) Resolve(searchPath SearchPath) (*FunctionDefinition, error)

+ func (fn ResolvableFunctionReference) Format(buf *bytes.Buffer, f FmtFlags)

+ func (fn ResolvableFunctionReference) String() string

+ type Restore struct

+ AsOf AsOfClause

+ From Exprs

+ Options KVOptions

+ Targets TargetList

+ func (*Restore) StatementTag() string

+ func (*Restore) StatementType() StatementType

+ func (n *Restore) String() string

+ func (node *Restore) Format(buf *bytes.Buffer, f FmtFlags)

+ func (stmt *Restore) CopyNode() *Restore

+ func (stmt *Restore) WalkStmt(v Visitor) Statement

+ type ResumeJob struct

+ ID Expr

+ func (*ResumeJob) StatementTag() string

+ func (*ResumeJob) StatementType() StatementType

+ func (n *ResumeJob) String() string

+ func (node *ResumeJob) Format(buf *bytes.Buffer, f FmtFlags)

+ type ReturningClause interface

+ type ReturningExprs SelectExprs

+ func (r *ReturningExprs) Format(buf *bytes.Buffer, f FmtFlags)

+ func (stmt *ReturningExprs) CopyNode() *ReturningExprs

+ type ReturningNothing struct

+ func (*ReturningNothing) Format(buf *bytes.Buffer, f FmtFlags)

+ type Revoke struct

+ Grantees NameList

+ Privileges privilege.List

+ Targets TargetList

+ func (*Revoke) StatementTag() string

+ func (*Revoke) StatementType() StatementType

+ func (n *Revoke) String() string

+ func (node *Revoke) Format(buf *bytes.Buffer, f FmtFlags)

+ type RollbackToSavepoint struct

+ Savepoint string

+ func (*RollbackToSavepoint) StatementTag() string

+ func (*RollbackToSavepoint) StatementType() StatementType

+ func (n *RollbackToSavepoint) String() string

+ func (node *RollbackToSavepoint) Format(buf *bytes.Buffer, f FmtFlags)

+ type RollbackTransaction struct

+ func (*RollbackTransaction) StatementTag() string

+ func (*RollbackTransaction) StatementType() StatementType

+ func (n *RollbackTransaction) String() string

+ func (node *RollbackTransaction) Format(buf *bytes.Buffer, f FmtFlags)

+ type Savepoint struct

+ Name string

+ func (*Savepoint) StatementTag() string

+ func (*Savepoint) StatementType() StatementType

+ func (n *Savepoint) String() string

+ func (node *Savepoint) Format(buf *bytes.Buffer, f FmtFlags)

+ type Scanner struct

+ func MakeScanner(str string) Scanner

+ func (s *Scanner) Error(e string)

+ func (s *Scanner) Lex(lval *sqlSymType) int

+ func (s *Scanner) SetHelp(msg HelpMessage)

+ func (s *Scanner) Tokens(f func(token int))

+ func (s *Scanner) Unimplemented(feature string)

+ func (s *Scanner) UnimplementedWithIssue(issue int)

+ type Scatter struct

+ From Exprs

+ Index *TableNameWithIndex

+ Table *NormalizableTableName

+ To Exprs

+ func (*Scatter) StatementTag() string

+ func (*Scatter) StatementType() StatementType

+ func (n *Scatter) String() string

+ func (node *Scatter) Format(buf *bytes.Buffer, f FmtFlags)

+ type SearchPath []string

+ type Select struct

+ Limit *Limit

+ OrderBy OrderBy

+ Select SelectStatement

+ func (*Select) StatementTag() string

+ func (*Select) StatementType() StatementType

+ func (n *Select) String() string

+ func (node *Select) Format(buf *bytes.Buffer, f FmtFlags)

+ func (stmt *Select) CopyNode() *Select

+ func (stmt *Select) WalkStmt(v Visitor) Statement

+ type SelectClause struct

+ Distinct bool

+ Exprs SelectExprs

+ From *From

+ GroupBy GroupBy

+ Having *Where

+ Where *Where

+ Window Window

+ func (*SelectClause) StatementTag() string

+ func (*SelectClause) StatementType() StatementType

+ func (n *SelectClause) String() string

+ func (node *SelectClause) Format(buf *bytes.Buffer, f FmtFlags)

+ func (stmt *SelectClause) CopyNode() *SelectClause

+ func (stmt *SelectClause) WalkStmt(v Visitor) Statement

+ type SelectExpr struct

+ As Name

+ Expr Expr

+ func (node *SelectExpr) NormalizeTopLevelVarName() error

+ func (node SelectExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ type SelectExprs []SelectExpr

+ func (node SelectExprs) Format(buf *bytes.Buffer, f FmtFlags)

+ type SelectStatement interface

+ type SemaContext struct

+ Location **time.Location

+ Placeholders PlaceholderInfo

+ SearchPath []string

+ func MakeSemaContext(privileged bool) SemaContext

+ type SetClusterSetting struct

+ Name VarName

+ Value Expr

+ func (*SetClusterSetting) StatementTag() string

+ func (*SetClusterSetting) StatementType() StatementType

+ func (n *SetClusterSetting) String() string

+ func (node *SetClusterSetting) Format(buf *bytes.Buffer, f FmtFlags)

+ func (stmt *SetClusterSetting) CopyNode() *SetClusterSetting

+ func (stmt *SetClusterSetting) WalkStmt(v Visitor) Statement

+ type SetDefaultIsolation struct

+ Isolation IsolationLevel

+ func (*SetDefaultIsolation) StatementTag() string

+ func (*SetDefaultIsolation) StatementType() StatementType

+ func (n *SetDefaultIsolation) String() string

+ func (node *SetDefaultIsolation) Format(buf *bytes.Buffer, f FmtFlags)

+ type SetTransaction struct

+ Modes TransactionModes

+ func (*SetTransaction) StatementTag() string

+ func (*SetTransaction) StatementType() StatementType

+ func (n *SetTransaction) String() string

+ func (node *SetTransaction) Format(buf *bytes.Buffer, f FmtFlags)

+ type SetVar struct

+ Name VarName

+ Values Exprs

+ func (*SetVar) StatementTag() string

+ func (*SetVar) StatementType() StatementType

+ func (n *SetVar) String() string

+ func (node *SetVar) Format(buf *bytes.Buffer, f FmtFlags)

+ func (stmt *SetVar) CopyNode() *SetVar

+ func (stmt *SetVar) WalkStmt(v Visitor) Statement

+ type ShowBackup struct

+ Path Expr

+ func (*ShowBackup) StatementTag() string

+ func (*ShowBackup) StatementType() StatementType

+ func (n *ShowBackup) String() string

+ func (node *ShowBackup) Format(buf *bytes.Buffer, f FmtFlags)

+ type ShowClusterSetting struct

+ Name string

+ func (*ShowClusterSetting) StatementTag() string

+ func (*ShowClusterSetting) StatementType() StatementType

+ func (n *ShowClusterSetting) String() string

+ func (node *ShowClusterSetting) Format(buf *bytes.Buffer, f FmtFlags)

+ type ShowColumns struct

+ Table NormalizableTableName

+ func (*ShowColumns) StatementTag() string

+ func (*ShowColumns) StatementType() StatementType

+ func (n *ShowColumns) String() string

+ func (node *ShowColumns) Format(buf *bytes.Buffer, f FmtFlags)

+ type ShowConstraints struct

+ Table NormalizableTableName

+ func (*ShowConstraints) StatementTag() string

+ func (*ShowConstraints) StatementType() StatementType

+ func (n *ShowConstraints) String() string

+ func (node *ShowConstraints) Format(buf *bytes.Buffer, f FmtFlags)

+ type ShowCreateTable struct

+ Table NormalizableTableName

+ func (*ShowCreateTable) StatementTag() string

+ func (*ShowCreateTable) StatementType() StatementType

+ func (n *ShowCreateTable) String() string

+ func (node *ShowCreateTable) Format(buf *bytes.Buffer, f FmtFlags)

+ type ShowCreateView struct

+ View NormalizableTableName

+ func (*ShowCreateView) StatementTag() string

+ func (*ShowCreateView) StatementType() StatementType

+ func (n *ShowCreateView) String() string

+ func (node *ShowCreateView) Format(buf *bytes.Buffer, f FmtFlags)

+ type ShowDatabases struct

+ func (*ShowDatabases) StatementTag() string

+ func (*ShowDatabases) StatementType() StatementType

+ func (n *ShowDatabases) String() string

+ func (node *ShowDatabases) Format(buf *bytes.Buffer, f FmtFlags)

+ type ShowFingerprints struct

+ Table *NormalizableTableName

+ func (*ShowFingerprints) StatementTag() string

+ func (*ShowFingerprints) StatementType() StatementType

+ func (n *ShowFingerprints) String() string

+ func (node *ShowFingerprints) Format(buf *bytes.Buffer, f FmtFlags)

+ type ShowGrants struct

+ Grantees NameList

+ Targets *TargetList

+ func (*ShowGrants) StatementTag() string

+ func (*ShowGrants) StatementType() StatementType

+ func (n *ShowGrants) String() string

+ func (node *ShowGrants) Format(buf *bytes.Buffer, f FmtFlags)

+ type ShowIndex struct

+ Table NormalizableTableName

+ func (*ShowIndex) StatementTag() string

+ func (*ShowIndex) StatementType() StatementType

+ func (n *ShowIndex) String() string

+ func (node *ShowIndex) Format(buf *bytes.Buffer, f FmtFlags)

+ type ShowJobs struct

+ func (*ShowJobs) StatementTag() string

+ func (*ShowJobs) StatementType() StatementType

+ func (n *ShowJobs) String() string

+ func (node *ShowJobs) Format(buf *bytes.Buffer, f FmtFlags)

+ type ShowQueries struct

+ Cluster bool

+ func (*ShowQueries) StatementTag() string

+ func (*ShowQueries) StatementType() StatementType

+ func (n *ShowQueries) String() string

+ func (node *ShowQueries) Format(buf *bytes.Buffer, f FmtFlags)

+ type ShowRanges struct

+ Index *TableNameWithIndex

+ Table *NormalizableTableName

+ func (*ShowRanges) StatementTag() string

+ func (*ShowRanges) StatementType() StatementType

+ func (n *ShowRanges) String() string

+ func (node *ShowRanges) Format(buf *bytes.Buffer, f FmtFlags)

+ type ShowSessions struct

+ Cluster bool

+ func (*ShowSessions) StatementTag() string

+ func (*ShowSessions) StatementType() StatementType

+ func (n *ShowSessions) String() string

+ func (node *ShowSessions) Format(buf *bytes.Buffer, f FmtFlags)

+ type ShowTables struct

+ Database Name

+ func (*ShowTables) StatementTag() string

+ func (*ShowTables) StatementType() StatementType

+ func (n *ShowTables) String() string

+ func (node *ShowTables) Format(buf *bytes.Buffer, f FmtFlags)

+ type ShowTrace struct

+ OnlyKVTrace bool

+ Statement Statement

+ func (*ShowTrace) StatementTag() string

+ func (*ShowTrace) StatementType() StatementType

+ func (n *ShowTrace) String() string

+ func (node *ShowTrace) Format(buf *bytes.Buffer, f FmtFlags)

+ type ShowTransactionStatus struct

+ func (*ShowTransactionStatus) StatementTag() string

+ func (*ShowTransactionStatus) StatementType() StatementType

+ func (n *ShowTransactionStatus) String() string

+ func (node *ShowTransactionStatus) Format(buf *bytes.Buffer, f FmtFlags)

+ type ShowUsers struct

+ func (*ShowUsers) StatementTag() string

+ func (*ShowUsers) StatementType() StatementType

+ func (n *ShowUsers) String() string

+ func (node *ShowUsers) Format(buf *bytes.Buffer, f FmtFlags)

+ type ShowVar struct

+ Name string

+ func (*ShowVar) StatementTag() string

+ func (*ShowVar) StatementType() StatementType

+ func (n *ShowVar) String() string

+ func (node *ShowVar) Format(buf *bytes.Buffer, f FmtFlags)

+ type SimpleVisitFn func(expr Expr) (err error, recurse bool, newExpr Expr)

+ type Split struct

+ Index *TableNameWithIndex

+ Rows *Select

+ Table *NormalizableTableName

+ func (*Split) StatementTag() string

+ func (*Split) StatementType() StatementType

+ func (n *Split) String() string

+ func (node *Split) Format(buf *bytes.Buffer, f FmtFlags)

+ type Statement interface

+ StatementTag func() string

+ StatementType func() StatementType

+ func ParseOne(sql string) (Statement, error)

+ func WalkStmt(v Visitor, stmt Statement) (newStmt Statement, changed bool)

+ type StatementList []Statement

+ func Parse(sql string) (StatementList, error)

+ func (l StatementList) Format(buf *bytes.Buffer, f FmtFlags)

+ func (l StatementList) String() string

+ type StatementSource struct

+ Statement Statement

+ func (node *StatementSource) Format(buf *bytes.Buffer, f FmtFlags)

+ type StatementType int

+ const Ack

+ const CopyIn

+ const DDL

+ const Rows

+ const RowsAffected

+ const Unknown

+ type StrVal struct

+ func NewStrVal(s string) *StrVal

+ func (expr *StrVal) AvailableTypes() []Type

+ func (expr *StrVal) DesirableTypes() []Type

+ func (expr *StrVal) Format(buf *bytes.Buffer, f FmtFlags)

+ func (expr *StrVal) ResolveAsType(ctx *SemaContext, typ Type) (Datum, error)

+ func (expr *StrVal) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

+ func (expr *StrVal) Walk(_ Visitor) Expr

+ func (node *StrVal) String() string

+ type StringColType struct

+ N int

+ Name string

+ func (node *StringColType) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *StringColType) String() string

+ type Subquery struct

+ Select SelectStatement

+ func (*Subquery) Variable()

+ func (expr *Subquery) TypeCheck(_ *SemaContext, desired Type) (TypedExpr, error)

+ func (expr *Subquery) Walk(v Visitor) Expr

+ func (node *Subquery) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *Subquery) String() string

+ type TArray struct

+ Typ Type

+ func (TArray) FamilyEqual(other Type) bool

+ func (TArray) Size() (uintptr, bool)

+ func (a TArray) Equivalent(other Type) bool

+ func (a TArray) IsAmbiguous() bool

+ func (a TArray) Oid() oid.Oid

+ func (a TArray) SQLName() string

+ func (a TArray) String() string

+ type TCollatedString struct

+ Locale string

+ func (TCollatedString) FamilyEqual(other Type) bool

+ func (TCollatedString) Oid() oid.Oid

+ func (TCollatedString) SQLName() string

+ func (TCollatedString) Size() (uintptr, bool)

+ func (t TCollatedString) Equivalent(other Type) bool

+ func (t TCollatedString) IsAmbiguous() bool

+ func (t TCollatedString) String() string

+ type TPlaceholder struct

+ Name string

+ func (TPlaceholder) FamilyEqual(other Type) bool

+ func (TPlaceholder) IsAmbiguous() bool

+ func (TPlaceholder) Oid() oid.Oid

+ func (TPlaceholder) SQLName() string

+ func (TPlaceholder) Size() (uintptr, bool)

+ func (t TPlaceholder) Equivalent(other Type) bool

+ func (t TPlaceholder) String() string

+ type TTable struct

+ Cols TTuple

+ func (TTable) FamilyEqual(other Type) bool

+ func (TTable) Oid() oid.Oid

+ func (TTable) SQLName() string

+ func (a TTable) Equivalent(other Type) bool

+ func (a TTable) IsAmbiguous() bool

+ func (a TTable) Size() (uintptr, bool)

+ func (a TTable) String() string

+ type TTuple []Type

+ func (TTuple) FamilyEqual(other Type) bool

+ func (TTuple) Oid() oid.Oid

+ func (TTuple) SQLName() string

+ func (t TTuple) Equivalent(other Type) bool

+ func (t TTuple) IsAmbiguous() bool

+ func (t TTuple) Size() (uintptr, bool)

+ func (t TTuple) String() string

+ type TableDef interface

+ type TableDefs []TableDef

+ func (node TableDefs) Format(buf *bytes.Buffer, f FmtFlags)

+ type TableExpr interface

+ type TableExprs []TableExpr

+ func (node TableExprs) Format(buf *bytes.Buffer, f FmtFlags)

+ type TableName struct

+ DBNameOriginallyOmitted bool

+ DatabaseName Name

+ PrefixName Name

+ PrefixOriginallySpecified bool

+ TableName Name

+ func ParseTableName(sql string) (*TableName, error)

+ func (t *TableName) Database() string

+ func (t *TableName) Format(buf *bytes.Buffer, f FmtFlags)

+ func (t *TableName) NormalizeTableName() (*TableName, error)

+ func (t *TableName) NormalizeTablePattern() (TablePattern, error)

+ func (t *TableName) QualifyWithDatabase(database string) error

+ func (t *TableName) String() string

+ func (t *TableName) Table() string

+ type TableNameReference interface

+ NormalizeTableName func() (*TableName, error)

+ type TableNameReferences []TableNameReference

+ func (t TableNameReferences) Format(buf *bytes.Buffer, f FmtFlags)

+ type TableNameWithIndex struct

+ Index Name

+ SearchTable bool

+ Table NormalizableTableName

+ func (n *TableNameWithIndex) Format(buf *bytes.Buffer, f FmtFlags)

+ type TableNameWithIndexList []*TableNameWithIndex

+ func (n TableNameWithIndexList) Format(buf *bytes.Buffer, f FmtFlags)

+ type TableNames []TableName

+ func (ts TableNames) Format(buf *bytes.Buffer, f FmtFlags)

+ func (ts TableNames) String() string

+ type TablePattern interface

+ NormalizeTablePattern func() (TablePattern, error)

+ type TablePatterns []TablePattern

+ func (tt TablePatterns) Format(buf *bytes.Buffer, f FmtFlags)

+ type TableRef struct

+ As AliasClause

+ Columns []ColumnID

+ TableID int64

+ func (n *TableRef) Format(buf *bytes.Buffer, f FmtFlags)

+ func (n *TableRef) String() string

+ type TargetList struct

+ Databases NameList

+ Tables TablePatterns

+ func (tl TargetList) Format(buf *bytes.Buffer, f FmtFlags)

+ func (tl TargetList) NormalizeTablesWithDatabase(db string) error

+ type TestingRelocate struct

+ Index *TableNameWithIndex

+ Rows *Select

+ Table *NormalizableTableName

+ func (*TestingRelocate) StatementTag() string

+ func (*TestingRelocate) StatementType() StatementType

+ func (n *TestingRelocate) String() string

+ func (node *TestingRelocate) Format(buf *bytes.Buffer, f FmtFlags)

+ type TimestampColType struct

+ func (node *TimestampColType) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *TimestampColType) String() string

+ type TimestampTZColType struct

+ func (node *TimestampTZColType) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *TimestampTZColType) String() string

+ type TransactionModes struct

+ Isolation IsolationLevel

+ ReadWriteMode ReadWriteMode

+ UserPriority UserPriority

+ func (node *TransactionModes) Format(buf *bytes.Buffer, f FmtFlags)

+ type Truncate struct

+ DropBehavior DropBehavior

+ Tables TableNameReferences

+ func (*Truncate) StatementTag() string

+ func (*Truncate) StatementType() StatementType

+ func (n *Truncate) String() string

+ func (node *Truncate) Format(buf *bytes.Buffer, f FmtFlags)

+ type Tuple struct

+ Exprs Exprs

+ func (expr *Tuple) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

+ func (expr *Tuple) Walk(v Visitor) Expr

+ func (node *Tuple) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *Tuple) ResolvedType() Type

+ func (node *Tuple) String() string

+ func (t *Tuple) Eval(ctx *EvalContext) (Datum, error)

+ type Type interface

+ Equivalent func(other Type) bool

+ FamilyEqual func(other Type) bool

+ IsAmbiguous func() bool

+ Oid func() oid.Oid

+ SQLName func() string

+ Size func() (uintptr, bool)

+ func CastTargetToDatumType(t CastTargetType) Type

+ func UnwrapType(t Type) Type

+ type TypedExpr interface

+ Eval func(*EvalContext) (Datum, error)

+ ResolvedType func() Type

+ func ReType(expr TypedExpr, wantedType Type) (TypedExpr, error)

+ func TypeCheck(expr Expr, ctx *SemaContext, desired Type) (TypedExpr, error)

+ func TypeCheckAndRequire(expr Expr, ctx *SemaContext, required Type, op string) (TypedExpr, error)

+ type TypedExprs []TypedExpr

+ func (node TypedExprs) String() string

+ type UUIDColType struct

+ func (node *UUIDColType) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *UUIDColType) String() string

+ type UnaryExpr struct

+ Expr Expr

+ Operator UnaryOperator

+ func (expr *UnaryExpr) Eval(ctx *EvalContext) (Datum, error)

+ func (expr *UnaryExpr) TypeCheck(ctx *SemaContext, desired Type) (TypedExpr, error)

+ func (expr *UnaryExpr) Walk(v Visitor) Expr

+ func (node *UnaryExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ func (node *UnaryExpr) String() string

+ func (node *UnaryExpr) TypedInnerExpr() TypedExpr

+ func (ta UnaryExpr) ResolvedType() Type

+ type UnaryOp struct

+ ReturnType Type

+ Typ Type

+ type UnaryOperator int

+ const UnaryComplement

+ const UnaryMinus

+ const UnaryPlus

+ func (i UnaryOperator) String() string

+ type UnionClause struct

+ All bool

+ Left *Select

+ Right *Select

+ Type UnionType

+ func (*UnionClause) StatementTag() string

+ func (*UnionClause) StatementType() StatementType

+ func (n *UnionClause) String() string

+ func (node *UnionClause) Format(buf *bytes.Buffer, f FmtFlags)

+ type UnionType int

+ const ExceptOp

+ const IntersectOp

+ const UnionOp

+ func (i UnionType) String() string

+ type UniqueConstraint struct

+ type UniqueConstraintTableDef struct

+ PrimaryKey bool

+ func (node *UniqueConstraintTableDef) Format(buf *bytes.Buffer, f FmtFlags)

+ type UnqualifiedStar struct

+ func (UnqualifiedStar) Format(buf *bytes.Buffer, _ FmtFlags)

+ func (UnqualifiedStar) ResolvedType() Type

+ func (UnqualifiedStar) Variable()

+ func (expr UnqualifiedStar) Eval(ctx *EvalContext) (Datum, error)

+ func (expr UnqualifiedStar) TypeCheck(_ *SemaContext, desired Type) (TypedExpr, error)

+ func (expr UnqualifiedStar) Walk(_ Visitor) Expr

+ func (u UnqualifiedStar) NormalizeVarName() (VarName, error)

+ func (u UnqualifiedStar) String() string

+ type UnresolvedName NameParts

+ func (UnresolvedName) ResolvedType() Type

+ func (UnresolvedName) Variable()

+ func (expr UnresolvedName) Eval(ctx *EvalContext) (Datum, error)

+ func (expr UnresolvedName) TypeCheck(s *SemaContext, desired Type) (TypedExpr, error)

+ func (expr UnresolvedName) Walk(_ Visitor) Expr

+ func (n UnresolvedName) NormalizeTableName() (*TableName, error)

+ func (n UnresolvedName) NormalizeTablePattern() (TablePattern, error)

+ func (n UnresolvedName) NormalizeUnqualifiedColumnItem() (*ColumnItem, error)

+ func (n UnresolvedName) NormalizeVarName() (VarName, error)

+ func (n UnresolvedName) ResolveFunction(searchPath SearchPath) (*FunctionDefinition, error)

+ func (u UnresolvedName) Format(buf *bytes.Buffer, f FmtFlags)

+ func (u UnresolvedName) String() string

+ type UnresolvedNames []UnresolvedName

+ func (u UnresolvedNames) Format(buf *bytes.Buffer, f FmtFlags)

+ type Update struct

+ Exprs UpdateExprs

+ Returning ReturningClause

+ Table TableExpr

+ Where *Where

+ func (*Update) StatementTag() string

+ func (n *Update) StatementType() StatementType

+ func (n *Update) String() string

+ func (node *Update) Format(buf *bytes.Buffer, f FmtFlags)

+ func (stmt *Update) CopyNode() *Update

+ func (stmt *Update) WalkStmt(v Visitor) Statement

+ type UpdateExpr struct

+ Expr Expr

+ Names UnresolvedNames

+ Tuple bool

+ func (node *UpdateExpr) Format(buf *bytes.Buffer, f FmtFlags)

+ type UpdateExprs []*UpdateExpr

+ func (node UpdateExprs) Format(buf *bytes.Buffer, f FmtFlags)

+ type UserPriority int

+ const High

+ const Low

+ const Normal

+ const UnspecifiedUserPriority

+ func (up UserPriority) String() string

+ type UsingJoinCond struct

+ Cols NameList

+ func (node *UsingJoinCond) Format(buf *bytes.Buffer, f FmtFlags)

+ type ValidationBehavior int

+ const ValidationDefault

+ const ValidationSkip

+ type ValueGenerator interface

+ Close func()

+ ColumnTypes func() TTuple

+ Next func() (bool, error)

+ Start func() error

+ Values func() Datums

+ type ValuesClause struct

+ Tuples []*Tuple

+ func (ValuesClause) StatementTag() string

+ func (ValuesClause) StatementType() StatementType

+ func (n *ValuesClause) String() string

+ func (node *ValuesClause) Format(buf *bytes.Buffer, f FmtFlags)

+ func (stmt *ValuesClause) WalkStmt(v Visitor) Statement

+ type VarName interface

+ NormalizeVarName func() (VarName, error)

+ func StarExpr() VarName

+ type VariableExpr interface

+ Variable func()

+ type VariadicType struct

+ Typ Type

+ func (v VariadicType) Length() int

+ func (v VariadicType) String() string

+ func (v VariadicType) Types() []Type

+ type VectorColType struct

+ Name string

+ ParamType ColumnType

+ func (node *VectorColType) Format(buf *bytes.Buffer, _ FmtFlags)

+ func (node *VectorColType) String() string

+ type Visitor interface

+ VisitPost func(expr Expr) (newNode Expr)

+ VisitPre func(expr Expr) (recurse bool, newExpr Expr)

+ type WalkableStmt interface

+ WalkStmt func(Visitor) Statement

+ type When struct

+ Cond Expr

+ Val Expr

+ func (node *When) Format(buf *bytes.Buffer, f FmtFlags)

+ type Where struct

+ Expr Expr

+ Type string

+ func (node *Where) Format(buf *bytes.Buffer, f FmtFlags)

+ type Window []*WindowDef

+ func (node Window) Format(buf *bytes.Buffer, f FmtFlags)

+ type WindowDef struct

+ Name Name

+ OrderBy OrderBy

+ Partitions Exprs

+ RefName Name

+ func (node *WindowDef) Format(buf *bytes.Buffer, f FmtFlags)

+ type WindowFrame struct

+ ArgCount int

+ ArgIdxStart int

+ FirstPeerIdx int

+ PeerRowCount int

+ RowIdx int

+ Rows []IndexedRow

+ type WindowFunc interface

+ Close func(context.Context, *EvalContext)

+ Compute func(context.Context, *EvalContext, WindowFrame) (Datum, error)

Incompatible versions in this module

v19.2.12+incompatible

Jan 12, 2021

v19.1.0+incompatible

Apr 24, 2019

v2.0.7+incompatible

Nov 28, 2018