tree

package

Go to main page

Versions in this module

v0

v0.25.2

Jun 5, 2025

Changes in this version

+ const AlterPolicyTag

+ const AstStraight

+ const CommentOnTypeTag

+ const ConfigureZoneTag

+ const CreateDatabaseTag

+ const CreatePolicyTag

+ const CreateTriggerTag

+ const DropPolicyTag

+ const DropTriggerTag

+ const FmtAlwaysQualifyNames

+ const FmtAlwaysQualifyUserDefinedTypeNames

+ const FmtBareReservedKeywords

+ const FmtCollapseLists

+ const FmtConstantsAsUnderscores

+ const FmtShortenConstants

+ const FmtShowFullURIs

+ const FmtSkipAsOfSystemTimeClauses

+ const OverloadPreferenceNone

+ const OverloadPreferencePreferred

+ const OverloadPreferenceUnpreferred

+ const SeqOptCacheNode

+ const StmtFingerprintPlaceholder

+ const UnknownOidName

+ const UnknownOidValue

+ var CannotAcceptTriggerErr = pgerror.New(pgcode.FeatureNotSupported, "cannot accept a value of type trigger")

+ var DNaNDecimal = &DDecimal

+ var DNegInfDecimal = &DDecimal

+ var DPosInfDecimal = &DDecimal

+ var EmptyDJSON = *NewDJSON(json.EmptyJSONValue)

+ var MaxSupportedTimeSec = float64(MaxSupportedTime.Unix())

+ var MinSupportedTimeSec = float64(MinSupportedTime.Unix())

+ var PlanGistFromCtx func(context.Context) string

+ var TriggerActionTimeFromTree = [...]semenumpb.TriggerActionTime

+ var TriggerActionTimeToTree = [...]TriggerActionTime

+ var TriggerEventTypeFromTree = [...]semenumpb.TriggerEventType

+ var TriggerEventTypeToTree = [...]TriggerEventType

+ var ValidateJSONPath func(string) (*jsonpath.Jsonpath, error)

+ func IsAllowedLDRSchemaChange(n Statement, virtualColNames []string, kvWriterEnabled bool) bool

+ func IsInParamClass(class RoutineParamClass) bool

+ func IsOutParamClass(class RoutineParamClass) bool

+ func IsSetOrResetSchemaLocked(n Statement) bool

+ func ParseTimestampTZ(ctx ParseContext, s string, precision time.Duration) (_ time.Time, dependsOnContext bool, _ error)

+ func ResolvePolymorphicArgTypes(paramTypes ParamTypes, argTypes []*types.T, anyElemTyp *types.T, ...) (ok bool, numPolyParams int, _ *types.T)

+ type AlterBackupScheduleNextRun struct

+ Full bool

+ func (node *AlterBackupScheduleNextRun) Format(ctx *FmtCtx)

+ type AlterJobOwner struct

+ Job Expr

+ Owner RoleSpec

+ func (*AlterJobOwner) StatementReturnType() StatementReturnType

+ func (*AlterJobOwner) StatementTag() string

+ func (*AlterJobOwner) StatementType() StatementType

+ func (n *AlterJobOwner) Format(ctx *FmtCtx)

+ func (n *AlterJobOwner) String() string

+ type AlterPolicy struct

+ Exprs PolicyExpressions

+ NewPolicyName Name

+ PolicyName Name

+ Roles RoleSpecList

+ TableName *UnresolvedObjectName

+ func (*AlterPolicy) StatementReturnType() StatementReturnType

+ func (*AlterPolicy) StatementTag() string

+ func (*AlterPolicy) StatementType() StatementType

+ func (n *AlterPolicy) String() string

+ func (node *AlterPolicy) Format(ctx *FmtCtx)

+ type AlterTableAddIdentity struct

+ Column Name

+ Qualification ColumnQualification

+ func (n *AlterTableAddIdentity) String() string

+ func (node *AlterTableAddIdentity) Format(ctx *FmtCtx)

+ func (node *AlterTableAddIdentity) GetColumn() Name

+ func (node *AlterTableAddIdentity) TelemetryName() string

+ type AlterTableDropIdentity struct

+ Column Name

+ IfExists bool

+ func (node *AlterTableDropIdentity) Format(ctx *FmtCtx)

+ func (node *AlterTableDropIdentity) GetColumn() Name

+ func (node *AlterTableDropIdentity) TelemetryName() string

+ type AlterTableIdentity struct

+ Column Name

+ SeqOptions SequenceOptions

+ func (n *AlterTableIdentity) String() string

+ func (node *AlterTableIdentity) Format(ctx *FmtCtx)

+ func (node *AlterTableIdentity) GetColumn() Name

+ func (node *AlterTableIdentity) TelemetryName() string

+ type AlterTableSetIdentity struct

+ Column Name

+ GeneratedAsIdentityType GeneratedIdentityType

+ func (node *AlterTableSetIdentity) Format(ctx *FmtCtx)

+ func (node *AlterTableSetIdentity) GetColumn() Name

+ func (node *AlterTableSetIdentity) TelemetryName() string

+ type AlterTableSetRLSMode struct

+ Mode TableRLSMode

+ func (node *AlterTableSetRLSMode) Format(ctx *FmtCtx)

+ func (node *AlterTableSetRLSMode) TelemetryName() string

type AlterTenantReplication

+ Producer bool

+ ReplicationSourceConnUri Expr

+ ReplicationSourceTenantName *TenantSpec

+ type AlterTenantReset struct

+ TenantSpec *TenantSpec

+ Timestamp Expr

+ func (*AlterTenantReset) StatementReturnType() StatementReturnType

+ func (*AlterTenantReset) StatementTag() string

+ func (*AlterTenantReset) StatementType() StatementType

+ func (n *AlterTenantReset) Format(ctx *FmtCtx)

+ func (n *AlterTenantReset) String() string

type BinaryOpEvaluator

+ EvalCosDistanceVectorOp func(context.Context, *CosDistanceVectorOp, Datum, Datum) (Datum, error)

+ EvalDistanceVectorOp func(context.Context, *DistanceVectorOp, Datum, Datum) (Datum, error)

+ EvalMinusPGVectorOp func(context.Context, *MinusPGVectorOp, Datum, Datum) (Datum, error)

+ EvalMultPGVectorOp func(context.Context, *MultPGVectorOp, Datum, Datum) (Datum, error)

+ EvalNegInnerProductVectorOp func(context.Context, *NegInnerProductVectorOp, Datum, Datum) (Datum, error)

+ EvalPlusPGVectorOp func(context.Context, *PlusPGVectorOp, Datum, Datum) (Datum, error)

type BlockState

+ CursorTimestamp *time.Time

+ Parent *BlockState

+ VariableCount int

+ type CheckExternalConnection struct

+ Options CheckExternalConnectionOptions

+ URI Expr

+ func (*CheckExternalConnection) StatementReturnType() StatementReturnType

+ func (*CheckExternalConnection) StatementTag() string

+ func (*CheckExternalConnection) StatementType() StatementType

+ func (c *CheckExternalConnection) Format(ctx *FmtCtx)

+ func (n *CheckExternalConnection) String() string

+ type CheckExternalConnectionOptions struct

+ Concurrency Expr

+ Duration Expr

+ TransferSize Expr

+ func (c *CheckExternalConnectionOptions) CombineWith(other *CheckExternalConnectionOptions) error

+ func (c *CheckExternalConnectionOptions) Format(ctx *FmtCtx)

+ func (c *CheckExternalConnectionOptions) IsDefault() bool

+ type CommentOnType struct

+ Comment *string

+ Name *UnresolvedObjectName

+ func (*CommentOnType) StatementReturnType() StatementReturnType

+ func (*CommentOnType) StatementTag() string

+ func (*CommentOnType) StatementType() StatementType

+ func (n *CommentOnType) Format(ctx *FmtCtx)

+ func (n *CommentOnType) String() string

+ type CommitPrepared struct

+ Transaction *StrVal

+ func (*CommitPrepared) StatementReturnType() StatementReturnType

+ func (*CommitPrepared) StatementTag() string

+ func (*CommitPrepared) StatementType() StatementType

+ func (n *CommitPrepared) String() string

+ func (node *CommitPrepared) Format(ctx *FmtCtx)

type CopyOptions

+ Encoding *StrVal

+ type CosDistanceVectorOp struct

+ func (op *CosDistanceVectorOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

type CreateIndex

+ Type idxtype.T

+ type CreateLogicalReplicationStream struct

+ CreateTable bool

+ From LogicalReplicationResources

+ Into LogicalReplicationResources

+ Options LogicalReplicationOptions

+ PGURL Expr

+ func (*CreateLogicalReplicationStream) StatementReturnType() StatementReturnType

+ func (*CreateLogicalReplicationStream) StatementTag() string

+ func (*CreateLogicalReplicationStream) StatementType() StatementType

+ func (n *CreateLogicalReplicationStream) String() string

+ func (node *CreateLogicalReplicationStream) Format(ctx *FmtCtx)

+ type CreatePolicy struct

+ Cmd PolicyCommand

+ Exprs PolicyExpressions

+ IfNotExists bool

+ PolicyName Name

+ Roles RoleSpecList

+ TableName *UnresolvedObjectName

+ Type PolicyType

+ func (*CreatePolicy) StatementReturnType() StatementReturnType

+ func (*CreatePolicy) StatementTag() string

+ func (*CreatePolicy) StatementType() StatementType

+ func (n *CreatePolicy) String() string

+ func (node *CreatePolicy) Format(ctx *FmtCtx)

type CreateTenantFromReplication

+ ReplicationSourceConnUri Expr

+ type CreateTrigger struct

+ ActionTime TriggerActionTime

+ Events []*TriggerEvent

+ ForEach TriggerForEach

+ FuncArgs []string

+ FuncBody string

+ FuncName *UnresolvedName

+ Name Name

+ Replace bool

+ TableName *UnresolvedObjectName

+ Transitions []*TriggerTransition

+ When Expr

+ func (*CreateTrigger) StatementReturnType() StatementReturnType

+ func (*CreateTrigger) StatementType() StatementType

+ func (n *CreateTrigger) StatementTag() string

+ func (n *CreateTrigger) String() string

+ func (node *CreateTrigger) Format(ctx *FmtCtx)

type DGeography

+ func (d *DGeography) DeterministicMemSize() uintptr

+ func (d *DGeography) ToJSON(maxDecimalDigits int) (json.JSON, error)

type DGeometry

+ func (d *DGeometry) DeterministicMemSize() uintptr

+ func (d *DGeometry) ToJSON(maxDecimalDigits int) (json.JSON, error)

+ type DJsonpath struct

+ func AsDJsonpath(e Expr) (*DJsonpath, bool)

+ func MustBeDJsonpath(e Expr) DJsonpath

+ func NewDJsonpath(d jsonpath.Jsonpath) *DJsonpath

+ func (*DJsonpath) AmbiguousFormat() bool

+ func (d *DJsonpath) Compare(ctx context.Context, cmpCtx CompareContext, other Datum) (int, error)

+ func (d *DJsonpath) Format(ctx *FmtCtx)

+ func (d *DJsonpath) IsMax(ctx context.Context, cmpCtx CompareContext) bool

+ func (d *DJsonpath) IsMin(ctx context.Context, cmpCtx CompareContext) bool

+ func (d *DJsonpath) Max(ctx context.Context, cmpCtx CompareContext) (Datum, bool)

+ func (d *DJsonpath) Min(ctx context.Context, cmpCtx CompareContext) (Datum, bool)

+ func (d *DJsonpath) Next(ctx context.Context, cmpCtx CompareContext) (Datum, bool)

+ func (d *DJsonpath) Prev(ctx context.Context, cmpCtx CompareContext) (Datum, bool)

+ func (d *DJsonpath) ResolvedType() *types.T

+ func (d *DJsonpath) Size() uintptr

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

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

+ func (node *DJsonpath) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DJsonpath) String() string

+ type DPGVector struct

+ func AsDPGVector(e Expr) (*DPGVector, bool)

+ func MustBeDPGVector(e Expr) *DPGVector

+ func NewDPGVector(vector vector.T) *DPGVector

+ func (d *DPGVector) AmbiguousFormat() bool

+ func (d *DPGVector) Compare(ctx context.Context, cmpCtx CompareContext, other Datum) (int, error)

+ func (d *DPGVector) Format(ctx *FmtCtx)

+ func (d *DPGVector) IsMax(ctx context.Context, cmpCtx CompareContext) bool

+ func (d *DPGVector) IsMin(ctx context.Context, cmpCtx CompareContext) bool

+ func (d *DPGVector) Max(ctx context.Context, cmpCtx CompareContext) (Datum, bool)

+ func (d *DPGVector) Min(ctx context.Context, cmpCtx CompareContext) (Datum, bool)

+ func (d *DPGVector) Next(ctx context.Context, cmpCtx CompareContext) (Datum, bool)

+ func (d *DPGVector) Prev(ctx context.Context, cmpCtx CompareContext) (Datum, bool)

+ func (d *DPGVector) ResolvedType() *types.T

+ func (d *DPGVector) Size() uintptr

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

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

+ func (node *DPGVector) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

type Datum

+ func ParseDJsonpath(s string) (Datum, error)

+ func ParseDPGVector(s string) (Datum, error)

type DatumAlloc

+ DefaultAllocSize int

+ func (a *DatumAlloc) AddTypeAllocSize(size int, t types.Family)

+ func (a *DatumAlloc) NewDJsonpath(v DJsonpath) *DJsonpath

+ func (a *DatumAlloc) ResetTypeAllocSizes()

+ type DistanceVectorOp struct

+ func (op *DistanceVectorOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type DoBlock struct

+ Code DoBlockBody

+ func (*DoBlock) StatementReturnType() StatementReturnType

+ func (*DoBlock) StatementTag() string

+ func (*DoBlock) StatementType() StatementType

+ func (n *DoBlock) Format(ctx *FmtCtx)

+ func (n *DoBlock) String() string

+ type DoBlockBody interface

+ IsDoBlockBody func()

+ VisitBody func(v Visitor) DoBlockBody

+ type DoBlockOption interface

+ type DoBlockOptions []DoBlockOption

+ type DropPolicy struct

+ DropBehavior DropBehavior

+ IfExists bool

+ PolicyName Name

+ TableName *UnresolvedObjectName

+ func (*DropPolicy) StatementReturnType() StatementReturnType

+ func (*DropPolicy) StatementTag() string

+ func (*DropPolicy) StatementType() StatementType

+ func (n *DropPolicy) String() string

+ func (node *DropPolicy) Format(ctx *FmtCtx)

+ type DropTrigger struct

+ DropBehavior DropBehavior

+ IfExists bool

+ Table *UnresolvedObjectName

+ Trigger Name

+ func (*DropTrigger) StatementReturnType() StatementReturnType

+ func (*DropTrigger) StatementType() StatementType

+ func (n *DropTrigger) StatementTag() string

+ func (n *DropTrigger) String() string

+ func (node *DropTrigger) Format(ctx *FmtCtx)

type ExprEvaluator

+ EvalTxnControlExpr func(context.Context, *TxnControlExpr) (Datum, error)

type FmtCtx

+ func (ctx *FmtCtx) Clone() *FmtCtx

+ func (ctx *FmtCtx) FormatStringConstant(s string)

+ func (ctx *FmtCtx) FormatStringDollarQuotes(s string)

+ func (ctx *FmtCtx) FormatURI(uri Expr)

+ func (ctx *FmtCtx) FormatURIs(uris []Expr)

+ func (ctx *FmtCtx) HasAnyFlags(f FmtFlags) bool

+ func (ctx *FmtCtx) WithAnnotations(ann *Annotations, fn func())

+ func (ctx *FmtCtx) WithoutConstantRedaction(fn func())

type HomogeneousType

+ func (HomogeneousType) MatchAtOid(typ *types.T, i int) bool

+ func (HomogeneousType) MatchOid(types []*types.T) bool

type IndexFlags

+ AvoidFullScan bool

+ ForceInvertedIndex bool

type IndexTableDef

+ Type idxtype.T

type IndexedVarHelper

+ func MakeIndexedVarHelperWithTypes(types []*types.T) IndexedVarHelper

type Insert

+ func (node *Insert) VectorInsert() bool

type IsolationLevel

+ func FromKVIsoLevel(level isolation.Level) IsolationLevel

+ func (i IsolationLevel) ToKVIsoLevel() isolation.Level

+ func (i IsolationLevel) UpgradeToEnabledLevel(allowReadCommitted, allowRepeatableRead, hasLicense bool) (_ IsolationLevel, upgraded, upgradedDueToLicense bool)

+ type LogicalReplicationOptions struct

+ BidirectionalURI Expr

+ Cursor Expr

+ DefaultFunction Expr

+ Discard Expr

+ MetricsLabel Expr

+ Mode Expr

+ ParentID Expr

+ SkipSchemaCheck *DBool

+ Unidirectional *DBool

+ UserFunctions map[UnresolvedName]RoutineName

+ func (lro *LogicalReplicationOptions) Format(ctx *FmtCtx)

+ func (o *LogicalReplicationOptions) CombineWith(other *LogicalReplicationOptions) error

+ func (o LogicalReplicationOptions) IsDefault() bool

+ type LogicalReplicationResources struct

+ Database Name

+ Tables []*UnresolvedName

+ func (lrr *LogicalReplicationResources) Format(ctx *FmtCtx)

+ type MinusPGVectorOp struct

+ func (op *MinusPGVectorOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MultPGVectorOp struct

+ func (op *MultPGVectorOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type NegInnerProductVectorOp struct

+ func (op *NegInnerProductVectorOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

type Overload

+ DefaultExprs Exprs

+ OutParamOrdinals []int32

+ OutParamTypes TypeList

+ RoutineParams RoutineParams

+ SecurityMode RoutineSecurity

+ func (b Overload) SignatureWithDefaults(simplify bool, includeDefaults bool) string

+ type OverloadPreference int

type ParamTypes

+ func (p ParamTypes) MatchAtOid(typ *types.T, i int) bool

+ func (p ParamTypes) MatchOid(types []*types.T) bool

+ func (p ParamTypes) StringWithDefaultExprs(defaultExprs []Expr) string

type PlaceholderIdx

+ func (idx PlaceholderIdx) SafeValue()

+ type PlusPGVectorOp struct

+ func (op *PlusPGVectorOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PolicyCommand int

+ const PolicyCommandAll

+ const PolicyCommandDefault

+ const PolicyCommandDelete

+ const PolicyCommandInsert

+ const PolicyCommandSelect

+ const PolicyCommandUpdate

+ func (p PolicyCommand) SafeValue()

+ func (p PolicyCommand) String() string

+ type PolicyExpressions struct

+ Using Expr

+ WithCheck Expr

+ func (node *PolicyExpressions) Format(ctx *FmtCtx)

+ type PolicyType int

+ const PolicyTypeDefault

+ const PolicyTypePermissive

+ const PolicyTypeRestrictive

+ func (p PolicyType) SafeValue()

+ func (p PolicyType) String() string

+ type PrepareTransaction struct

+ Transaction *StrVal

+ func (*PrepareTransaction) StatementReturnType() StatementReturnType

+ func (*PrepareTransaction) StatementTag() string

+ func (*PrepareTransaction) StatementType() StatementType

+ func (n *PrepareTransaction) String() string

+ func (node *PrepareTransaction) Format(ctx *FmtCtx)

type PrettyCfg

+ FmtFlags FmtFlags

type ReferenceActions

+ func (node *ReferenceActions) HasDisallowedActionForComputedFKCol() bool

+ func (node *ReferenceActions) HasUpdateAction() bool

type RefreshMaterializedView

+ AsOf AsOfClause

type RegexpCache

+ func (rc *RegexpCache) GetRegexpWithFlags(key RegexpCacheKey, flags syntax.Flags) (*regexp.Regexp, error)

type ResolvedFunctionDefinition

+ UnsupportedWithIssue uint

+ func (fd *ResolvedFunctionDefinition) MakeUnsupportedError() error

type RestoreOptions

+ ExperimentalCopy bool

+ func (opts *RestoreOptions) OnlineImpl() bool

+ type RollbackPrepared struct

+ Transaction *StrVal

+ func (*RollbackPrepared) StatementReturnType() StatementReturnType

+ func (*RollbackPrepared) StatementTag() string

+ func (*RollbackPrepared) StatementType() StatementType

+ func (n *RollbackPrepared) String() string

+ func (node *RollbackPrepared) Format(ctx *FmtCtx)

type RoutineBodyStr

+ func AnalyzeDoBlockOptions(options DoBlockOptions) (RoutineBodyStr, error)

type RoutineExpr

+ BlockStart bool

+ DiscardLastStmtResult bool

+ FirstStmtResultWriter RoutineResultWriter

+ TriggerFunc bool

type RoutineParam

+ func (node *RoutineParam) IsInParam() bool

+ func (node *RoutineParam) IsOutParam() bool

type RoutineParamClass

+ const RoutineParamDefault

+ type RoutineResultWriter interface

+ type RoutineSecurity int

+ const RoutineDefiner

+ const RoutineInvoker

+ func (node RoutineSecurity) Format(ctx *FmtCtx)

type SchemaExprContext

+ const PolicyUsingExpr

+ const PolicyWithCheckExpr

type SemaContext

+ UsePre_25_2VariadicBuiltins bool

type SemaProperties

+ IgnoreUnpreferredOverloads bool

+ RoutineUseResolvedType bool

+ func (s *SemaProperties) Context() string

type ShowCreateFormatOption

+ const ShowCreateFormatOptionIgnoreFKs

+ type ShowCreateTrigger struct

+ Name Name

+ TableName *UnresolvedObjectName

+ func (*ShowCreateTrigger) StatementReturnType() StatementReturnType

+ func (*ShowCreateTrigger) StatementType() StatementType

+ func (n *ShowCreateTrigger) StatementTag() string

+ func (n *ShowCreateTrigger) String() string

+ func (node *ShowCreateTrigger) Format(ctx *FmtCtx)

+ type ShowDefaultSessionVariablesForRole struct

+ All bool

+ IsRole bool

+ Name RoleSpec

+ func (*ShowDefaultSessionVariablesForRole) StatementReturnType() StatementReturnType

+ func (*ShowDefaultSessionVariablesForRole) StatementTag() string

+ func (*ShowDefaultSessionVariablesForRole) StatementType() StatementType

+ func (n *ShowDefaultSessionVariablesForRole) String() string

+ func (node *ShowDefaultSessionVariablesForRole) Format(ctx *FmtCtx)

+ type ShowExternalConnections struct

+ ConnectionLabel Expr

+ func (*ShowExternalConnections) StatementReturnType() StatementReturnType

+ func (*ShowExternalConnections) StatementTag() string

+ func (*ShowExternalConnections) StatementType() StatementType

+ func (n *ShowExternalConnections) String() string

+ func (node *ShowExternalConnections) Format(ctx *FmtCtx)

+ type ShowFingerprintOptions struct

+ ExcludedUserColumns StringOrPlaceholderOptList

+ StartTimestamp Expr

+ func (s *ShowFingerprintOptions) CombineWith(other *ShowFingerprintOptions) error

+ func (s *ShowFingerprintOptions) Format(ctx *FmtCtx)

+ func (s ShowFingerprintOptions) IsDefault() bool

type ShowFingerprints

+ Options ShowFingerprintOptions

+ type ShowLogicalReplicationJobs struct

+ func (*ShowLogicalReplicationJobs) StatementReturnType() StatementReturnType

+ func (*ShowLogicalReplicationJobs) StatementTag() string

+ func (*ShowLogicalReplicationJobs) StatementType() StatementType

+ func (n *ShowLogicalReplicationJobs) String() string

+ func (node *ShowLogicalReplicationJobs) Format(ctx *FmtCtx)

+ type ShowLogicalReplicationJobsOptions struct

+ WithDetails bool

+ type ShowPolicies struct

+ Table *UnresolvedObjectName

+ func (*ShowPolicies) StatementReturnType() StatementReturnType

+ func (*ShowPolicies) StatementTag() string

+ func (*ShowPolicies) StatementType() StatementType

+ func (n *ShowPolicies) String() string

+ func (node *ShowPolicies) Format(ctx *FmtCtx)

type ShowSchemas

+ WithComment bool

type ShowTenantOptions

+ WithPriorReplication bool

+ type ShowTriggers struct

+ Table *UnresolvedObjectName

+ func (*ShowTriggers) StatementReturnType() StatementReturnType

+ func (*ShowTriggers) StatementTag() string

+ func (*ShowTriggers) StatementType() StatementType

+ func (n *ShowTriggers) String() string

+ func (node *ShowTriggers) Format(ctx *FmtCtx)

type ShowTypes

+ WithComment bool

type SpecializedVectorizedBuiltin

+ const CrdbInternalRangeStatsWithErrors

type Statement

+ func UnwrapExplain(stmt Statement) Statement

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

+ type StoredProcContinuation interface

+ type StoredProcTxnOp uint8

+ const StoredProcTxnCommit

+ const StoredProcTxnNoOp

+ const StoredProcTxnRollback

+ func (txnOp StoredProcTxnOp) String() string

+ type TableRLSMode int

+ const TableRLSDisable

+ const TableRLSEnable

+ const TableRLSForce

+ const TableRLSNoForce

+ func (r TableRLSMode) SafeValue()

+ func (r TableRLSMode) String() string

+ func (r TableRLSMode) TelemetryName() string

type TenantReplicationOptions

+ EnableReaderTenant *DBool

+ ExpirationWindow Expr

+ func (o TenantReplicationOptions) ExpirationWindowSet() bool

+ type TriggerActionTime uint8

+ const TriggerActionTimeAfter

+ const TriggerActionTimeBefore

+ const TriggerActionTimeInsteadOf

+ const TriggerActionTimeUnknown

+ func (node *TriggerActionTime) Format(ctx *FmtCtx)

+ type TriggerEvent struct

+ Columns NameList

+ EventType TriggerEventType

+ func (node *TriggerEvent) Format(ctx *FmtCtx)

+ type TriggerEventType uint8

+ const TriggerEventDelete

+ const TriggerEventInsert

+ const TriggerEventTruncate

+ const TriggerEventTypeMax

+ const TriggerEventTypeUnknown

+ const TriggerEventUpdate

+ func (node *TriggerEventType) Format(ctx *FmtCtx)

+ func (node *TriggerEventType) String() string

+ type TriggerEventTypeSet uint8

+ func MakeTriggerEventTypeSet(types ...TriggerEventType) TriggerEventTypeSet

+ func (s *TriggerEventTypeSet) Add(t TriggerEventType)

+ func (s TriggerEventTypeSet) Contains(t TriggerEventType) bool

+ type TriggerForEach uint8

+ const TriggerForEachRow

+ const TriggerForEachStatement

+ func (node *TriggerForEach) Format(ctx *FmtCtx)

+ type TriggerTransition struct

+ IsNew bool

+ IsRow bool

+ Name Name

+ func (node *TriggerTransition) Format(ctx *FmtCtx)

+ type TxnControlExpr struct

+ Args TypedExprs

+ Gen TxnControlPlanGenerator

+ Modes TransactionModes

+ Name string

+ Op StoredProcTxnOp

+ Typ *types.T

+ func NewTxnControlExpr(opType StoredProcTxnOp, txnModes TransactionModes, args TypedExprs, ...) *TxnControlExpr

+ func (node *TxnControlExpr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *TxnControlExpr) Format(ctx *FmtCtx)

+ func (node *TxnControlExpr) ResolvedType() *types.T

+ func (node *TxnControlExpr) String() string

+ func (node *TxnControlExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error)

+ func (node *TxnControlExpr) Walk(v Visitor) Expr

+ type TxnControlPlanGenerator func(ctx context.Context, args Datums) (StoredProcContinuation, error)

type TypeList

+ MatchAtOid func(typ *types.T, i int) bool

+ MatchOid func(types []*types.T) bool

type UniqueConstraintTableDef

+ FormatAsIndex bool

type UnresolvedObjectName

+ func (u *UnresolvedObjectName) ToTypeName() TypeName

type VariadicType

+ func (VariadicType) MatchAtOid(typ *types.T, i int) bool

+ func (VariadicType) MatchOid(types []*types.T) bool

type ZoneConfigSettings

+ Discard bool

type ZoneSpecifier

+ StarIndex bool

v0.23.2

Feb 12, 2024

Changes in this version

+ const AllFuncType

+ const AlterTableTag

+ const AnnotateExplicit

+ const AnnotateShort

+ const AstCross

+ const AstFull

+ const AstHash

+ const AstHaving

+ const AstInner

+ const AstInverted

+ const AstLeft

+ const AstLookup

+ const AstMerge

+ const AstRight

+ const AstWhere

+ const BackupTag

+ const CastExplicit

+ const CastPrepend

+ const CastShort

+ const ColumnLimit

+ const CommentOnColumnTag

+ const CommentOnConstraintTag

+ const CommentOnDatabaseTag

+ const CommentOnIndexTag

+ const CommentOnSchemaTag

+ const CommentOnTableTag

+ const ConsoleLineWidth

+ const CreateFunctionTag

+ const CreateIndexTag

+ const CreateProcedureTag

+ const CreateSchemaTag

+ const CreateSequenceTag

+ const DefaultLineWidth

+ const DistinctFuncType

+ const DropDatabaseTag

+ const DropFunctionTag

+ const DropIndexTag

+ const DropOwnedByTag

+ const DropProcedureTag

+ const DropSchemaTag

+ const DropSequenceTag

+ const DropTableTag

+ const DropTypeTag

+ const DropViewTag

+ const FmtAlwaysGroupExprs

+ const FmtAlwaysQualifyTableNames

+ const FmtAnonymize

+ const FmtArrayToString

+ const FmtBareIdentifiers

+ const FmtBareStrings

+ const FmtCheckEquivalence

+ const FmtExport

+ const FmtHideConstants

+ const FmtMarkRedactionNode

+ const FmtOmitNameRedaction

+ const FmtPGCatalog

+ const FmtParsable

+ const FmtParsableNumerics

+ const FmtPgwireText

+ const FmtSerializable

+ const FmtShowPasswords

+ const FmtShowTableAliases

+ const FmtShowTypes

+ const FmtSimple

+ const FmtSummary

+ const FmtSymbolicSubqueries

+ const FmtTagDollarQuotes

+ const ImportTag

+ const LikeTableOptAll

+ const MaxPlaceholderIdx

+ const NoColumnIdx

+ const PGDateFormat

+ const PGTime2400Format

+ const PGTimeFormat

+ const PGTimeStampFormat

+ const PGTimeStampFormatNoOffset

+ const PGTimeTZFormat

+ const PasswordSubstitution

+ const PrettyAlignAndDeindent

+ const PrettyAlignAndExtraIndent

+ const PrettyAlignOnly

+ const PrettyNoAlign

+ const PrimaryRegionNotSpecifiedName

+ const RegionEnum

+ const RegionalByRowRegionDefaultCol

+ const RegionalByRowRegionDefaultColName

+ const RegionalByRowRegionNotSpecifiedName

+ const RestoreTag

+ const ScrubDatabase

+ const ScrubTable

+ const SecondaryRegionNotSpecifiedName

+ const SeqOptAs

+ const SeqOptCache

+ const SeqOptCycle

+ const SeqOptIncrement

+ const SeqOptMaxValue

+ const SeqOptMinValue

+ const SeqOptNoCycle

+ const SeqOptOwnedBy

+ const SeqOptRestart

+ const SeqOptStart

+ const SeqOptVirtual

+ const TableLimit

+ const ZeroOidValue

+ var AbsentReturningClause = &NoReturningClause

+ var BinOps = map[treebin.BinaryOperatorSymbol]*BinOpOverloads

+ var CmpOps = cmpOpFixups(map[treecmp.ComparisonOperatorSymbol]*CmpOpOverloads{ ... })

+ var CompositeKeyMatchMethodType = [...]CompositeKeyMatchMethod

+ var CompositeKeyMatchMethodValue = [...]semenumpb.Match

+ var DBoolFalse = &constDBoolFalse

+ var DBoolTrue = &constDBoolTrue

+ var DMaxIPAddr = NewDIPAddr(DIPAddr{ ... })

+ var DMaxTimeTZ = NewDTimeTZFromOffset(timeofday.Max, timetz.MaxTimeTZOffsetSecs)

+ var DMaxUUID = NewDUuid(DUuid{ ... })

+ var DMinIPAddr = NewDIPAddr(DIPAddr{ ... })

+ var DMinTimeTZ = NewDTimeTZFromOffset(timeofday.Min, timetz.MinTimeTZOffsetSecs)

+ var DMinUUID = NewDUuid(DUuid{ ... })

+ var DNaNFloat = NewDFloat(DFloat(math.NaN()))

+ var DNegInfFloat = NewDFloat(DFloat(math.Inf(-1)))

+ var DNull Datum = dNull

+ var DPosInfFloat = NewDFloat(DFloat(math.Inf(+1)))

+ var DTimeMaxTimeRegex = regexp.MustCompile(`^([0-9-]*(\s|T))?\s*24:00(:00(.0+)?)?\s*$`)

+ var DVoidDatum = &DVoid

+ var DZero = NewDInt(0)

+ var DZeroDecimal = &DDecimal

+ var DZeroFloat = NewDFloat(0)

+ var DZeroTimestamp = &DTimestamp

+ var DZeroTimestampTZ = &DTimestampTZ

+ var DecimalCtx = &apd.Context

+ var ErrAsOfSpecifiedWithReadWrite = pgerror.New(pgcode.Syntax, "AS OF SYSTEM TIME specified with READ WRITE mode")

+ var ErrCharOutOfRange = pgerror.New(pgcode.NumericValueOutOfRange, "\"char\" out of range")

+ var ErrConflictingRoutineOption = pgerror.New(pgcode.Syntax, "conflicting or redundant options")

+ var ErrDecOutOfRange = pgerror.New(pgcode.NumericValueOutOfRange, "decimal out of range")

+ var ErrDivByZero = pgerror.New(pgcode.DivisionByZero, "division by zero")

+ var ErrFloatOutOfRange = pgerror.New(pgcode.NumericValueOutOfRange, "float out of range")

+ var ErrInt2OutOfRange = pgerror.New(pgcode.NumericValueOutOfRange, "integer out of range for type int2")

+ var ErrInt4OutOfRange = pgerror.New(pgcode.NumericValueOutOfRange, "integer out of range for type int4")

+ var ErrIntOutOfRange = pgerror.New(pgcode.NumericValueOutOfRange, "integer out of range")

+ var ErrRoutineUndefined = pgerror.Newf(pgcode.UndefinedFunction, "routine undefined")

+ var ErrShiftArgOutOfRange = pgerror.New(pgcode.InvalidParameterValue, "shift argument out of range")

+ var ErrSqrtOfNegNumber = pgerror.New(pgcode.InvalidArgumentForPowerFunction, ...)

+ var ExactCtx = DecimalCtx.WithPrecision(0)

+ var ForeignKeyReferenceActionType = [...]ReferenceAction

+ var ForeignKeyReferenceActionValue = [...]semenumpb.ForeignKeyAction

+ var FunDefs map[string]*FunctionDefinition

+ var HighPrecisionCtx = DecimalCtx.WithPrecision(2000)

+ var IntermediateCtx = DecimalCtx.WithPrecision(DecimalCtx.Precision + 5)

+ var IsolationLevelMap = map[string]IsolationLevel

+ var JobCommandToStatement = map[JobCommand]string

+ var MaxSupportedTime = timeutil.Unix(9224318016000 - 1, 999999000)

+ var MinSupportedTime = timeutil.Unix(-210866803200, 0)

+ var NumValAvailDecimalNoFraction = append(decimalLikeTypes, intLikeTypes)

+ var NumValAvailDecimalNoFractionNoOid = append(decimalLikeTypes, types.Int)

+ var NumValAvailDecimalWithFraction = decimalLikeTypes

+ var NumValAvailInteger = append(intLikeTypes, decimalLikeTypes)

+ var NumValAvailIntegerNoOid = append([]*types.T{ ... }, decimalLikeTypes)

+ var OidToBuiltinName map[oid.Oid]string

+ var OidToQualifiedBuiltinOverload map[oid.Oid]QualifiedOverload

+ var OnCastTypeCheck map[CastCounterType]func()

+ var OnTypeCheckArrayConstructor func()

+ var OnTypeCheckArrayFlatten func()

+ var OnTypeCheckArraySubscript func()

+ var OnTypeCheckIfErr func()

+ var OnTypeCheckJSONBSubscript func()

+ var ResolvedBuiltinFuncDefs map[string]*ResolvedFunctionDefinition

+ var ReturningNothingClause = &ReturningNothing

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

+ var ShowLastQueryStatisticsDefaultColumns = NameList([]Name{ ... })

+ var StrValAvailAllParsable = []*types.T

+ var StrValAvailBytes = []*types.T

+ var UnaryOpName = [...]string

+ var UnaryOps = unaryOpFixups(map[UnaryOperatorSymbol]*UnaryOpOverloads{ ... })

+ var UnknownReturnType *types.T

+ func AsJSON(d Datum, dcc sessiondatapb.DataConversionConfig, loc *time.Location) (json.JSON, error)

+ func AsString(n NodeFormatter) string

+ func AsStringWithFQNames(n NodeFormatter, ann *Annotations) string

+ func AsStringWithFlags(n NodeFormatter, fl FmtFlags, opts ...FmtCtxOption) string

+ func CanModifySchema(stmt Statement) bool

+ func CanWriteData(stmt Statement) bool

+ func CheckIsWindowOrAgg(def *ResolvedFunctionDefinition) error

+ func CheckUnsupportedType(ctx context.Context, semaCtx *SemaContext, typ *types.T) error

+ func CmpOpInverse(i treecmp.ComparisonOperatorSymbol) (treecmp.ComparisonOperatorSymbol, bool)

+ func CompareBools(d, v bool) int

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

+ func ComputeColNameInternal(ctx context.Context, sp SearchPath, target Expr, ...) (int, string, error)

+ func ContainsVars(expr Expr) bool

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

+ func EqualComparisonFunctionExists(leftType, rightType *types.T) bool

+ func ErrNameString(s string) string

+ func ErrNameStringP(s *string) string

+ func ErrString(n NodeFormatter) string

+ func ExplainFlags() map[string]ExplainFlag

+ func ExplainModes() map[string]ExplainMode

+ func ExprDebugString(expr Expr) string

+ func FoldComparisonExpr(op treecmp.ComparisonOperator, left, right Expr) (newOp treecmp.ComparisonOperator, newLeft Expr, newRight Expr, flipped bool, ...)

+ func FoldComparisonExprWithDatums(op treecmp.ComparisonOperator, left, right Datum) (newOp treecmp.ComparisonOperator, newLeft Datum, newRight Datum, flipped bool, ...)

+ func FormatDate(d pgdate.Date, ctx *FmtCtx)

+ func FormatDuration(d duration.Duration, ctx *FmtCtx)

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

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

+ func GetJSONPath(j json.JSON, ary DArray) (json.JSON, error)

+ func GetParamsAndReturnType(impl overloadImpl) (TypeList, ReturnTyper)

+ func GetRenderColName(ctx context.Context, searchPath SearchPath, target SelectExpr, ...) (string, error)

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

+ func GetTableType(isSequence bool, isView bool, isMaterialized bool) string

+ func HasReturningClause(clause ReturningClause) bool

+ func InferBinaryType(bin treebin.BinaryOperatorSymbol, leftType, rightType *types.T) *types.T

+ func InferTypes(vals []string) []types.Family

+ func IsReferenceSerialType(ref ResolvableTypeReference) bool

+ func IsUnaryComplement(op Operator) bool

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

+ func MakeParseError(s string, typ *types.T, err error) error

+ func MaxDistinctCount(evalCtx CompareContext, first, last Datum) (_ int64, ok bool)

+ func MemoizeComparisonExprOp(node *ComparisonExpr)

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

+ func MustBeStaticallyKnownType(ref ResolvableTypeReference) *types.T

+ func NameString(s string) string

+ func NameStringP(s *string) string

+ func NewAggInAggError() error

+ func NewCannotMixBitArraySizesError(op string) error

+ func NewContextDependentOpsNotAllowedError(context string) error

+ func NewInvalidFunctionUsageError(class FunctionClass, context string) error

+ func NewInvalidNestedSRFError(context string) error

+ func NewNoValueProvidedForPlaceholderErr(pIdx PlaceholderIdx) error

+ func NewTimestampExceedsBoundsError(t time.Time) error

+ func NewTypeIsNotCompositeError(resolvedType *types.T) error

+ func OperatorIsImmutable(expr Expr) bool

+ func PGWireFormatTime(t timeofday.TimeOfDay, tmp []byte) []byte

+ func PGWireFormatTimeTZ(t timetz.TimeTZ, tmp []byte) []byte

+ func PGWireFormatTimestamp(t time.Time, offset *time.Location, tmp []byte) (b []byte)

+ func PGWireTypeSize(t *types.T) int

+ func ParseAndRequireStringHandler(t *types.T, s string, ctx ParseContext, vh ValueHandler, ...) (err error)

+ func ParseBool(s string) (bool, error)

+ func ParseIntervalWithTypeMetadata(style duration.IntervalStyle, s string, itm types.IntervalTypeMetadata) (duration.Duration, error)

+ func ParsePath(str string) []string

+ func PgwireFormatBool(d bool) byte

+ func PgwireFormatFloat(buf []byte, fl float64, conv sessiondatapb.DataConversionConfig, ...) []byte

+ func Pretty(stmt NodeFormatter) (string, error)

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

+ func ResolveBlankPaddedChar(s string, t *types.T) string

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

+ func ReturnsAtMostOneRow(stmt Statement) bool

+ func Serialize(n NodeFormatter) string

+ func SerializeForDisplay(n NodeFormatter) string

+ func StmtDebugString(stmt Statement) string

+ func TestingEnableFamilyIndexHint() func()

+ func TimeFamilyPrecisionToRoundDuration(precision int32) time.Duration

+ func TimeFromDatumForComparison(ctx CompareContext, d Datum) (time.Time, error)

+ func ValidateRoutineOptions(options RoutineOptions) error

+ func WalkExprConst(v Visitor, expr Expr)

+ type AbbreviatedGrant struct

+ Grantees RoleSpecList

+ Privileges privilege.List

+ Target privilege.TargetObjectType

+ WithGrantOption bool

+ func (n *AbbreviatedGrant) Format(ctx *FmtCtx)

+ type AbbreviatedRevoke struct

+ GrantOptionFor bool

+ Grantees RoleSpecList

+ Privileges privilege.List

+ Target privilege.TargetObjectType

+ func (n *AbbreviatedRevoke) Format(ctx *FmtCtx)

+ type AggType int

+ const GeneralAgg

+ const OrderedSetAgg

+ type AggregateOverload interface

+ Aggregate func()

+ type AliasClause struct

+ Alias Name

+ Cols ColumnDefList

+ func (f *AliasClause) Format(ctx *FmtCtx)

+ type AliasedTableExpr struct

+ As AliasClause

+ Expr TableExpr

+ IndexFlags *IndexFlags

+ Lateral bool

+ Ordinality bool

+ func (expr *AliasedTableExpr) WalkTableExpr(v Visitor) TableExpr

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

+ func (node *AliasedTableExpr) String() string

+ type AllColumnsSelector struct

+ TableName *UnresolvedObjectName

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

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

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

+ func (a *AllColumnsSelector) String() string

+ func (a *AllColumnsSelector) Variable()

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

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

+ func (node *AllColumnsSelector) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ type AllTablesSelector struct

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

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

+ func (at *AllTablesSelector) String() string

+ type AlterBackup struct

+ Backup Expr

+ Cmds AlterBackupCmds

+ Subdir Expr

+ func (*AlterBackup) StatementReturnType() StatementReturnType

+ func (*AlterBackup) StatementTag() string

+ func (*AlterBackup) StatementType() StatementType

+ func (n *AlterBackup) String() string

+ func (node *AlterBackup) Format(ctx *FmtCtx)

+ type AlterBackupCmd interface

+ type AlterBackupCmds []AlterBackupCmd

+ func (node *AlterBackupCmds) Format(ctx *FmtCtx)

+ type AlterBackupKMS struct

+ KMSInfo BackupKMS

+ func (node *AlterBackupKMS) Format(ctx *FmtCtx)

+ type AlterBackupSchedule struct

+ Cmds AlterBackupScheduleCmds

+ ScheduleID uint64

+ func (*AlterBackupSchedule) StatementReturnType() StatementReturnType

+ func (*AlterBackupSchedule) StatementTag() string

+ func (*AlterBackupSchedule) StatementType() StatementType

+ func (n *AlterBackupSchedule) String() string

+ func (node *AlterBackupSchedule) Format(ctx *FmtCtx)

+ type AlterBackupScheduleCmd interface

+ type AlterBackupScheduleCmds []AlterBackupScheduleCmd

+ func (n *AlterBackupScheduleCmds) String() string

+ func (node *AlterBackupScheduleCmds) Format(ctx *FmtCtx)

+ type AlterBackupScheduleSetFullBackup struct

+ FullBackup FullBackupClause

+ func (node *AlterBackupScheduleSetFullBackup) Format(ctx *FmtCtx)

+ type AlterBackupScheduleSetInto struct

+ Into StringOrPlaceholderOptList

+ func (node *AlterBackupScheduleSetInto) Format(ctx *FmtCtx)

+ type AlterBackupScheduleSetLabel struct

+ Label Expr

+ func (node *AlterBackupScheduleSetLabel) Format(ctx *FmtCtx)

+ type AlterBackupScheduleSetRecurring struct

+ Recurrence Expr

+ func (node *AlterBackupScheduleSetRecurring) Format(ctx *FmtCtx)

+ type AlterBackupScheduleSetScheduleOption struct

+ Option KVOption

+ func (node *AlterBackupScheduleSetScheduleOption) Format(ctx *FmtCtx)

+ type AlterBackupScheduleSetWith struct

+ With *BackupOptions

+ func (node *AlterBackupScheduleSetWith) Format(ctx *FmtCtx)

+ type AlterChangefeed struct

+ Cmds AlterChangefeedCmds

+ Jobs Expr

+ func (*AlterChangefeed) StatementReturnType() StatementReturnType

+ func (*AlterChangefeed) StatementTag() string

+ func (*AlterChangefeed) StatementType() StatementType

+ func (n *AlterChangefeed) String() string

+ func (node *AlterChangefeed) Format(ctx *FmtCtx)

+ type AlterChangefeedAddTarget struct

+ Options KVOptions

+ Targets ChangefeedTargets

+ func (node *AlterChangefeedAddTarget) Format(ctx *FmtCtx)

+ type AlterChangefeedCmd interface

+ type AlterChangefeedCmds []AlterChangefeedCmd

+ func (n *AlterChangefeedCmds) String() string

+ func (node *AlterChangefeedCmds) Format(ctx *FmtCtx)

+ type AlterChangefeedDropTarget struct

+ Targets ChangefeedTargets

+ func (node *AlterChangefeedDropTarget) Format(ctx *FmtCtx)

+ type AlterChangefeedSetOptions struct

+ Options KVOptions

+ func (node *AlterChangefeedSetOptions) Format(ctx *FmtCtx)

+ type AlterChangefeedUnsetOptions struct

+ Options NameList

+ func (node *AlterChangefeedUnsetOptions) Format(ctx *FmtCtx)

+ type AlterDatabaseAddRegion struct

+ IfNotExists bool

+ Name Name

+ Region Name

+ func (*AlterDatabaseAddRegion) StatementReturnType() StatementReturnType

+ func (*AlterDatabaseAddRegion) StatementTag() string

+ func (*AlterDatabaseAddRegion) StatementType() StatementType

+ func (n *AlterDatabaseAddRegion) String() string

+ func (node *AlterDatabaseAddRegion) Format(ctx *FmtCtx)

+ type AlterDatabaseAddSuperRegion struct

+ DatabaseName Name

+ Regions []Name

+ SuperRegionName Name

+ func (*AlterDatabaseAddSuperRegion) StatementReturnType() StatementReturnType

+ func (*AlterDatabaseAddSuperRegion) StatementTag() string

+ func (*AlterDatabaseAddSuperRegion) StatementType() StatementType

+ func (n *AlterDatabaseAddSuperRegion) String() string

+ func (node *AlterDatabaseAddSuperRegion) Format(ctx *FmtCtx)

+ type AlterDatabaseAlterSuperRegion struct

+ DatabaseName Name

+ Regions []Name

+ SuperRegionName Name

+ func (*AlterDatabaseAlterSuperRegion) StatementReturnType() StatementReturnType

+ func (*AlterDatabaseAlterSuperRegion) StatementTag() string

+ func (*AlterDatabaseAlterSuperRegion) StatementType() StatementType

+ func (n *AlterDatabaseAlterSuperRegion) String() string

+ func (node *AlterDatabaseAlterSuperRegion) Format(ctx *FmtCtx)

+ type AlterDatabaseDropRegion struct

+ IfExists bool

+ Name Name

+ Region Name

+ func (*AlterDatabaseDropRegion) StatementReturnType() StatementReturnType

+ func (*AlterDatabaseDropRegion) StatementTag() string

+ func (*AlterDatabaseDropRegion) StatementType() StatementType

+ func (n *AlterDatabaseDropRegion) String() string

+ func (node *AlterDatabaseDropRegion) Format(ctx *FmtCtx)

+ type AlterDatabaseDropSecondaryRegion struct

+ DatabaseName Name

+ IfExists bool

+ func (*AlterDatabaseDropSecondaryRegion) StatementReturnType() StatementReturnType

+ func (*AlterDatabaseDropSecondaryRegion) StatementTag() string

+ func (*AlterDatabaseDropSecondaryRegion) StatementType() StatementType

+ func (n *AlterDatabaseDropSecondaryRegion) String() string

+ func (node *AlterDatabaseDropSecondaryRegion) Format(ctx *FmtCtx)

+ type AlterDatabaseDropSuperRegion struct

+ DatabaseName Name

+ SuperRegionName Name

+ func (*AlterDatabaseDropSuperRegion) StatementReturnType() StatementReturnType

+ func (*AlterDatabaseDropSuperRegion) StatementTag() string

+ func (*AlterDatabaseDropSuperRegion) StatementType() StatementType

+ func (n *AlterDatabaseDropSuperRegion) String() string

+ func (node *AlterDatabaseDropSuperRegion) Format(ctx *FmtCtx)

+ type AlterDatabaseOwner struct

+ Name Name

+ Owner RoleSpec

+ func (*AlterDatabaseOwner) StatementReturnType() StatementReturnType

+ func (*AlterDatabaseOwner) StatementTag() string

+ func (*AlterDatabaseOwner) StatementType() StatementType

+ func (n *AlterDatabaseOwner) String() string

+ func (node *AlterDatabaseOwner) Format(ctx *FmtCtx)

+ type AlterDatabasePlacement struct

+ Name Name

+ Placement DataPlacement

+ func (*AlterDatabasePlacement) StatementReturnType() StatementReturnType

+ func (*AlterDatabasePlacement) StatementTag() string

+ func (*AlterDatabasePlacement) StatementType() StatementType

+ func (n *AlterDatabasePlacement) String() string

+ func (node *AlterDatabasePlacement) Format(ctx *FmtCtx)

+ type AlterDatabasePrimaryRegion struct

+ Name Name

+ PrimaryRegion Name

+ func (*AlterDatabasePrimaryRegion) StatementReturnType() StatementReturnType

+ func (*AlterDatabasePrimaryRegion) StatementTag() string

+ func (*AlterDatabasePrimaryRegion) StatementType() StatementType

+ func (n *AlterDatabasePrimaryRegion) String() string

+ func (node *AlterDatabasePrimaryRegion) Format(ctx *FmtCtx)

+ type AlterDatabaseSecondaryRegion struct

+ DatabaseName Name

+ SecondaryRegion Name

+ func (*AlterDatabaseSecondaryRegion) StatementReturnType() StatementReturnType

+ func (*AlterDatabaseSecondaryRegion) StatementTag() string

+ func (*AlterDatabaseSecondaryRegion) StatementType() StatementType

+ func (n *AlterDatabaseSecondaryRegion) String() string

+ func (node *AlterDatabaseSecondaryRegion) Format(ctx *FmtCtx)

+ type AlterDatabaseSetZoneConfigExtension struct

+ DatabaseName Name

+ LocalityLevel LocalityLevel

+ RegionName Name

+ func (*AlterDatabaseSetZoneConfigExtension) StatementReturnType() StatementReturnType

+ func (*AlterDatabaseSetZoneConfigExtension) StatementTag() string

+ func (*AlterDatabaseSetZoneConfigExtension) StatementType() StatementType

+ func (n *AlterDatabaseSetZoneConfigExtension) String() string

+ func (node *AlterDatabaseSetZoneConfigExtension) Format(ctx *FmtCtx)

+ type AlterDatabaseSurvivalGoal struct

+ Name Name

+ SurvivalGoal SurvivalGoal

+ func (*AlterDatabaseSurvivalGoal) StatementReturnType() StatementReturnType

+ func (*AlterDatabaseSurvivalGoal) StatementTag() string

+ func (*AlterDatabaseSurvivalGoal) StatementType() StatementType

+ func (n *AlterDatabaseSurvivalGoal) String() string

+ func (node *AlterDatabaseSurvivalGoal) Format(ctx *FmtCtx)

+ type AlterDefaultPrivileges struct

+ Database *Name

+ ForAllRoles bool

+ Grant AbbreviatedGrant

+ IsGrant bool

+ Revoke AbbreviatedRevoke

+ Roles RoleSpecList

+ Schemas ObjectNamePrefixList

+ func (*AlterDefaultPrivileges) StatementReturnType() StatementReturnType

+ func (*AlterDefaultPrivileges) StatementTag() string

+ func (*AlterDefaultPrivileges) StatementType() StatementType

+ func (n *AlterDefaultPrivileges) Format(ctx *FmtCtx)

+ func (n *AlterDefaultPrivileges) String() string

+ type AlterFunctionDepExtension struct

+ Extension Name

+ Function RoutineObj

+ Remove bool

+ func (*AlterFunctionDepExtension) StatementReturnType() StatementReturnType

+ func (*AlterFunctionDepExtension) StatementTag() string

+ func (*AlterFunctionDepExtension) StatementType() StatementType

+ func (n *AlterFunctionDepExtension) String() string

+ func (node *AlterFunctionDepExtension) Format(ctx *FmtCtx)

+ type AlterFunctionOptions struct

+ Function RoutineObj

+ Options RoutineOptions

+ func (*AlterFunctionOptions) StatementReturnType() StatementReturnType

+ func (*AlterFunctionOptions) StatementTag() string

+ func (*AlterFunctionOptions) StatementType() StatementType

+ func (n *AlterFunctionOptions) String() string

+ func (node *AlterFunctionOptions) Format(ctx *FmtCtx)

+ type AlterIndex struct

+ Cmds AlterIndexCmds

+ IfExists bool

+ Index TableIndexName

+ func (*AlterIndex) StatementReturnType() StatementReturnType

+ func (*AlterIndex) StatementTag() string

+ func (*AlterIndex) StatementType() StatementType

+ func (n *AlterIndex) String() string

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

+ type AlterIndexCmd interface

+ type AlterIndexCmds []AlterIndexCmd

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

+ type AlterIndexPartitionBy struct

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

+ type AlterIndexVisible struct

+ IfExists bool

+ Index TableIndexName

+ Invisibility IndexInvisibility

+ func (*AlterIndexVisible) StatementReturnType() StatementReturnType

+ func (*AlterIndexVisible) StatementTag() string

+ func (*AlterIndexVisible) StatementType() StatementType

+ func (n *AlterIndexVisible) String() string

+ func (node *AlterIndexVisible) Format(ctx *FmtCtx)

+ type AlterRole struct

+ IfExists bool

+ IsRole bool

+ KVOptions KVOptions

+ Name RoleSpec

+ func (*AlterRole) StatementReturnType() StatementReturnType

+ func (*AlterRole) StatementTag() string

+ func (*AlterRole) StatementType() StatementType

+ func (n *AlterRole) String() string

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

+ type AlterRoleSet struct

+ AllRoles bool

+ DatabaseName Name

+ IfExists bool

+ IsRole bool

+ RoleName RoleSpec

+ SetOrReset *SetVar

+ func (*AlterRoleSet) StatementReturnType() StatementReturnType

+ func (*AlterRoleSet) StatementTag() string

+ func (*AlterRoleSet) StatementType() StatementType

+ func (n *AlterRoleSet) String() string

+ func (node *AlterRoleSet) Format(ctx *FmtCtx)

+ type AlterRoutineRename struct

+ Function RoutineObj

+ NewName Name

+ Procedure bool

+ func (*AlterRoutineRename) StatementReturnType() StatementReturnType

+ func (*AlterRoutineRename) StatementType() StatementType

+ func (n *AlterRoutineRename) StatementTag() string

+ func (n *AlterRoutineRename) String() string

+ func (node *AlterRoutineRename) Format(ctx *FmtCtx)

+ type AlterRoutineSetOwner struct

+ Function RoutineObj

+ NewOwner RoleSpec

+ Procedure bool

+ func (*AlterRoutineSetOwner) StatementReturnType() StatementReturnType

+ func (*AlterRoutineSetOwner) StatementType() StatementType

+ func (n *AlterRoutineSetOwner) StatementTag() string

+ func (n *AlterRoutineSetOwner) String() string

+ func (node *AlterRoutineSetOwner) Format(ctx *FmtCtx)

+ type AlterRoutineSetSchema struct

+ Function RoutineObj

+ NewSchemaName Name

+ Procedure bool

+ func (*AlterRoutineSetSchema) StatementReturnType() StatementReturnType

+ func (*AlterRoutineSetSchema) StatementType() StatementType

+ func (n *AlterRoutineSetSchema) StatementTag() string

+ func (n *AlterRoutineSetSchema) String() string

+ func (node *AlterRoutineSetSchema) Format(ctx *FmtCtx)

+ type AlterSchema struct

+ Cmd AlterSchemaCmd

+ Schema ObjectNamePrefix

+ func (*AlterSchema) StatementReturnType() StatementReturnType

+ func (*AlterSchema) StatementTag() string

+ func (*AlterSchema) StatementType() StatementType

+ func (n *AlterSchema) String() string

+ func (node *AlterSchema) Format(ctx *FmtCtx)

+ type AlterSchemaCmd interface

+ type AlterSchemaOwner struct

+ Owner RoleSpec

+ func (node *AlterSchemaOwner) Format(ctx *FmtCtx)

+ type AlterSchemaRename struct

+ NewName Name

+ func (node *AlterSchemaRename) Format(ctx *FmtCtx)

+ type AlterSequence struct

+ IfExists bool

+ Name *UnresolvedObjectName

+ Options SequenceOptions

+ func (*AlterSequence) StatementReturnType() StatementReturnType

+ func (*AlterSequence) StatementTag() string

+ func (*AlterSequence) StatementType() StatementType

+ func (n *AlterSequence) String() string

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

+ type AlterTable struct

+ Cmds AlterTableCmds

+ IfExists bool

+ Table *UnresolvedObjectName

+ func (*AlterTable) StatementReturnType() StatementReturnType

+ func (*AlterTable) StatementTag() string

+ func (*AlterTable) StatementType() StatementType

+ func (n *AlterTable) String() string

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

+ func (node *AlterTable) HoistAddColumnConstraints(onHoistedFKConstraint func())

+ type AlterTableAddColumn struct

+ ColumnDef *ColumnTableDef

+ IfNotExists bool

+ func (n *AlterTableAddColumn) String() string

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

+ func (node *AlterTableAddColumn) TelemetryName() string

+ type AlterTableAddConstraint struct

+ ConstraintDef ConstraintTableDef

+ ValidationBehavior ValidationBehavior

+ func (n *AlterTableAddConstraint) String() string

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

+ func (node *AlterTableAddConstraint) TelemetryName() string

+ type AlterTableAlterColumnType struct

+ Collation string

+ Column Name

+ ToType ResolvableTypeReference

+ Using Expr

+ func (n *AlterTableAlterColumnType) String() string

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

+ func (node *AlterTableAlterColumnType) GetColumn() Name

+ func (node *AlterTableAlterColumnType) TelemetryName() string

+ type AlterTableAlterPrimaryKey struct

+ Columns IndexElemList

+ Name Name

+ Sharded *ShardedIndexDef

+ StorageParams StorageParams

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

+ func (node *AlterTableAlterPrimaryKey) TelemetryName() string

+ type AlterTableCmd interface

+ TelemetryName func() string

+ type AlterTableCmds []AlterTableCmd

+ func (n *AlterTableCmds) String() string

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

+ type AlterTableDropColumn struct

+ Column Name

+ DropBehavior DropBehavior

+ IfExists bool

+ func (n *AlterTableDropColumn) String() string

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

+ func (node *AlterTableDropColumn) TelemetryName() string

+ type AlterTableDropConstraint struct

+ Constraint Name

+ DropBehavior DropBehavior

+ IfExists bool

+ func (n *AlterTableDropConstraint) String() string

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

+ func (node *AlterTableDropConstraint) TelemetryName() string

+ type AlterTableDropNotNull struct

+ Column Name

+ func (n *AlterTableDropNotNull) String() string

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

+ func (node *AlterTableDropNotNull) GetColumn() Name

+ func (node *AlterTableDropNotNull) TelemetryName() string

+ type AlterTableDropStored struct

+ Column Name

+ func (n *AlterTableDropStored) String() string

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

+ func (node *AlterTableDropStored) GetColumn() Name

+ func (node *AlterTableDropStored) TelemetryName() string

+ type AlterTableInjectStats struct

+ Stats Expr

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

+ func (node *AlterTableInjectStats) TelemetryName() string

+ type AlterTableLocality struct

+ IfExists bool

+ Locality *Locality

+ Name *UnresolvedObjectName

+ func (*AlterTableLocality) StatementReturnType() StatementReturnType

+ func (*AlterTableLocality) StatementTag() string

+ func (*AlterTableLocality) StatementType() StatementType

+ func (n *AlterTableLocality) String() string

+ func (node *AlterTableLocality) Format(ctx *FmtCtx)

+ type AlterTableOwner struct

+ IfExists bool

+ IsMaterialized bool

+ IsSequence bool

+ IsView bool

+ Name *UnresolvedObjectName

+ Owner RoleSpec

+ func (*AlterTableOwner) StatementReturnType() StatementReturnType

+ func (*AlterTableOwner) StatementTag() string

+ func (*AlterTableOwner) StatementType() StatementType

+ func (n *AlterTableOwner) String() string

+ func (node *AlterTableOwner) Format(ctx *FmtCtx)

+ func (node *AlterTableOwner) TelemetryName() string

+ type AlterTablePartitionByTable struct

+ func (node *AlterTablePartitionByTable) Format(ctx *FmtCtx)

+ func (node *AlterTablePartitionByTable) TelemetryName() string

+ type AlterTableRenameColumn struct

+ Column Name

+ NewName Name

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

+ func (node *AlterTableRenameColumn) TelemetryName() string

+ type AlterTableRenameConstraint struct

+ Constraint Name

+ NewName Name

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

+ func (node *AlterTableRenameConstraint) TelemetryName() string

+ type AlterTableResetStorageParams struct

+ Params NameList

+ func (node *AlterTableResetStorageParams) Format(ctx *FmtCtx)

+ func (node *AlterTableResetStorageParams) TelemetryName() string

+ type AlterTableSetAudit struct

+ Mode AuditMode

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

+ func (node *AlterTableSetAudit) TelemetryName() string

+ type AlterTableSetDefault struct

+ Column Name

+ Default Expr

+ func (n *AlterTableSetDefault) String() string

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

+ func (node *AlterTableSetDefault) GetColumn() Name

+ func (node *AlterTableSetDefault) TelemetryName() string

+ type AlterTableSetNotNull struct

+ Column Name

+ func (n *AlterTableSetNotNull) String() string

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

+ func (node *AlterTableSetNotNull) GetColumn() Name

+ func (node *AlterTableSetNotNull) TelemetryName() string

+ type AlterTableSetOnUpdate struct

+ Column Name

+ Expr Expr

+ func (node *AlterTableSetOnUpdate) Format(ctx *FmtCtx)

+ func (node *AlterTableSetOnUpdate) GetColumn() Name

+ func (node *AlterTableSetOnUpdate) TelemetryName() string

+ type AlterTableSetSchema struct

+ IfExists bool

+ IsMaterialized bool

+ IsSequence bool

+ IsView bool

+ Name *UnresolvedObjectName

+ Schema Name

+ func (*AlterTableSetSchema) StatementReturnType() StatementReturnType

+ func (*AlterTableSetSchema) StatementType() StatementType

+ func (n *AlterTableSetSchema) StatementTag() string

+ func (n *AlterTableSetSchema) String() string

+ func (node *AlterTableSetSchema) Format(ctx *FmtCtx)

+ func (node *AlterTableSetSchema) TelemetryName() string

+ type AlterTableSetStorageParams struct

+ StorageParams StorageParams

+ func (node *AlterTableSetStorageParams) Format(ctx *FmtCtx)

+ func (node *AlterTableSetStorageParams) TelemetryName() string

+ type AlterTableSetVisible struct

+ Column Name

+ Visible bool

+ func (n *AlterTableSetVisible) String() string

+ func (node *AlterTableSetVisible) Format(ctx *FmtCtx)

+ func (node *AlterTableSetVisible) GetColumn() Name

+ func (node *AlterTableSetVisible) TelemetryName() string

+ type AlterTableValidateConstraint struct

+ Constraint Name

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

+ func (node *AlterTableValidateConstraint) TelemetryName() string

+ type AlterTenantCapability struct

+ AllCapabilities bool

+ Capabilities []TenantCapability

+ IsRevoke bool

+ TenantSpec *TenantSpec

+ func (*AlterTenantCapability) StatementReturnType() StatementReturnType

+ func (*AlterTenantCapability) StatementTag() string

+ func (*AlterTenantCapability) StatementType() StatementType

+ func (n *AlterTenantCapability) Format(ctx *FmtCtx)

+ func (n *AlterTenantCapability) String() string

+ type AlterTenantRename struct

+ NewName *TenantSpec

+ TenantSpec *TenantSpec

+ func (*AlterTenantRename) StatementReturnType() StatementReturnType

+ func (*AlterTenantRename) StatementTag() string

+ func (*AlterTenantRename) StatementType() StatementType

+ func (n *AlterTenantRename) Format(ctx *FmtCtx)

+ func (n *AlterTenantRename) String() string

+ type AlterTenantReplication struct

+ Command JobCommand

+ Cutover *ReplicationCutoverTime

+ Options TenantReplicationOptions

+ TenantSpec *TenantSpec

+ func (*AlterTenantReplication) StatementReturnType() StatementReturnType

+ func (*AlterTenantReplication) StatementTag() string

+ func (*AlterTenantReplication) StatementType() StatementType

+ func (n *AlterTenantReplication) Format(ctx *FmtCtx)

+ func (n *AlterTenantReplication) String() string

+ type AlterTenantService struct

+ Command TenantServiceCmd

+ TenantSpec *TenantSpec

+ func (*AlterTenantService) StatementReturnType() StatementReturnType

+ func (*AlterTenantService) StatementTag() string

+ func (*AlterTenantService) StatementType() StatementType

+ func (n *AlterTenantService) Format(ctx *FmtCtx)

+ func (n *AlterTenantService) String() string

+ type AlterTenantSetClusterSetting struct

+ TenantSpec *TenantSpec

+ func (*AlterTenantSetClusterSetting) StatementReturnType() StatementReturnType

+ func (*AlterTenantSetClusterSetting) StatementTag() string

+ func (*AlterTenantSetClusterSetting) StatementType() StatementType

+ func (n *AlterTenantSetClusterSetting) Format(ctx *FmtCtx)

+ func (n *AlterTenantSetClusterSetting) String() string

+ type AlterType struct

+ Cmd AlterTypeCmd

+ Type *UnresolvedObjectName

+ func (*AlterType) StatementReturnType() StatementReturnType

+ func (*AlterType) StatementTag() string

+ func (*AlterType) StatementType() StatementType

+ func (n *AlterType) String() string

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

+ type AlterTypeAddValue struct

+ IfNotExists bool

+ NewVal EnumValue

+ Placement *AlterTypeAddValuePlacement

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

+ func (node *AlterTypeAddValue) TelemetryName() string

+ type AlterTypeAddValuePlacement struct

+ Before bool

+ ExistingVal EnumValue

+ type AlterTypeCmd interface

+ TelemetryName func() string

+ type AlterTypeDropValue struct

+ Val EnumValue

+ func (node *AlterTypeDropValue) Format(ctx *FmtCtx)

+ func (node *AlterTypeDropValue) TelemetryName() string

+ type AlterTypeOwner struct

+ Owner RoleSpec

+ func (node *AlterTypeOwner) Format(ctx *FmtCtx)

+ func (node *AlterTypeOwner) TelemetryName() string

+ type AlterTypeRename struct

+ NewName Name

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

+ func (node *AlterTypeRename) TelemetryName() string

+ type AlterTypeRenameValue struct

+ NewVal EnumValue

+ OldVal EnumValue

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

+ func (node *AlterTypeRenameValue) TelemetryName() string

+ type AlterTypeSetSchema struct

+ Schema Name

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

+ func (node *AlterTypeSetSchema) TelemetryName() string

+ type Analyze struct

+ Table TableExpr

+ func (*Analyze) StatementReturnType() StatementReturnType

+ func (*Analyze) StatementTag() string

+ func (*Analyze) StatementType() StatementType

+ func (n *Analyze) String() string

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

+ type AndExpr struct

+ Left Expr

+ Right Expr

+ func NewTypedAndExpr(left, right TypedExpr) *AndExpr

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

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

+ func (node *AndExpr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

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

+ func (node *AndExpr) String() string

+ func (node *AndExpr) TypedLeft() TypedExpr

+ func (node *AndExpr) TypedRight() TypedExpr

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

+ type AnnotateTypeExpr struct

+ Expr Expr

+ SyntaxMode annotateSyntaxMode

+ Type ResolvableTypeReference

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

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

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

+ func (node *AnnotateTypeExpr) String() string

+ func (node *AnnotateTypeExpr) TypedInnerExpr() TypedExpr

+ type AnnotatedNode struct

+ AnnIdx AnnotationIdx

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

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

+ type AnnotationIdx int32

+ const NoAnnotation

+ type Annotations []interface

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

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

+ func MakeAnnotations(numAnnotations AnnotationIdx) Annotations

+ type AppendToMaybeNullArrayOp struct

+ Typ *types.T

+ func (op *AppendToMaybeNullArrayOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type Array struct

+ Exprs Exprs

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

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

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

+ func (node *Array) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

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

+ func (node *Array) String() string

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

+ type ArrayFlatten struct

+ Subquery Expr

+ func NewTypedArrayFlattenExpr(input Expr) *ArrayFlatten

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

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

+ func (node *ArrayFlatten) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

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

+ func (node *ArrayFlatten) String() string

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

+ type ArraySubscript struct

+ Begin Expr

+ End Expr

+ Slice bool

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

+ type ArraySubscripts []*ArraySubscript

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

+ type ArrayTypeReference struct

+ ElementType ResolvableTypeReference

+ func (node *ArrayTypeReference) Format(ctx *FmtCtx)

+ func (node *ArrayTypeReference) SQLString() string

+ type AsOfClause struct

+ Expr Expr

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

+ type AuditMode int

+ const AuditModeDisable

+ const AuditModeReadWrite

+ func (m AuditMode) String() string

+ func (m AuditMode) TelemetryName() string

+ type Backup struct

+ AppendToLatest bool

+ AsOf AsOfClause

+ IncrementalFrom Exprs

+ Nested bool

+ Options BackupOptions

+ Subdir Expr

+ Targets *BackupTargetList

+ To StringOrPlaceholderOptList

+ func (*Backup) StatementReturnType() StatementReturnType

+ func (*Backup) StatementTag() string

+ func (*Backup) StatementType() StatementType

+ func (n *Backup) String() string

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

+ func (node Backup) Coverage() DescriptorCoverage

+ type BackupKMS struct

+ NewKMSURI StringOrPlaceholderOptList

+ OldKMSURI StringOrPlaceholderOptList

+ type BackupOptions struct

+ CaptureRevisionHistory Expr

+ Detached *DBool

+ EncryptionKMSURI StringOrPlaceholderOptList

+ EncryptionPassphrase Expr

+ ExecutionLocality Expr

+ IncludeAllSecondaryTenants Expr

+ IncrementalStorage StringOrPlaceholderOptList

+ UpdatesClusterMonitoringMetrics Expr

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

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

+ func (o BackupOptions) IsDefault() bool

+ type BackupTargetList struct

+ Databases NameList

+ Schemas ObjectNamePrefixList

+ Tables TableAttrs

+ TenantID TenantID

+ func (tl *BackupTargetList) Format(ctx *FmtCtx)

+ type Batch struct

+ Params []BatchParam

+ func (b *Batch) Format(ctx *FmtCtx)

+ type BatchParam interface

+ type BeginTransaction struct

+ FormatWithStart bool

+ Modes TransactionModes

+ func (*BeginTransaction) StatementReturnType() StatementReturnType

+ func (*BeginTransaction) StatementTag() string

+ func (*BeginTransaction) StatementType() StatementType

+ func (n *BeginTransaction) String() string

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

+ type BinOp struct

+ CalledOnNullInput bool

+ EvalOp BinaryEvalOp

+ LeftType *types.T

+ OnTypeCheck func()

+ PreferredOverload bool

+ ReturnType *types.T

+ RightType *types.T

+ Volatility volatility.V

+ func FindBinaryOverload(bin treebin.BinaryOperatorSymbol, leftType, rightType *types.T) (ret *BinOp, ok bool)

+ type BinOpOverloads struct

+ func (o *BinOpOverloads) ForEachBinOp(f func(op *BinOp) error) error

+ func (o *BinOpOverloads) LookupImpl(left, right *types.T) (*BinOp, bool)

+ type BinaryEvalOp interface

+ Eval func(context.Context, OpEvaluator, Datum, Datum) (Datum, error)

+ type BinaryExpr struct

+ Left Expr

+ Op *BinOp

+ Operator treebin.BinaryOperator

+ Right Expr

+ func NewBinExprIfValidOverload(op treebin.BinaryOperator, left TypedExpr, right TypedExpr) *BinaryExpr

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

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

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

+ func (node *BinaryExpr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

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

+ func (node *BinaryExpr) ResolvedBinOp() *BinOp

+ func (node *BinaryExpr) String() string

+ func (node *BinaryExpr) TypedLeft() TypedExpr

+ func (node *BinaryExpr) TypedRight() TypedExpr

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

+ type BinaryOpEvaluator interface

+ EvalAppendToMaybeNullArrayOp func(context.Context, *AppendToMaybeNullArrayOp, Datum, Datum) (Datum, error)

+ EvalBitAndINetOp func(context.Context, *BitAndINetOp, Datum, Datum) (Datum, error)

+ EvalBitAndIntOp func(context.Context, *BitAndIntOp, Datum, Datum) (Datum, error)

+ EvalBitAndVarBitOp func(context.Context, *BitAndVarBitOp, Datum, Datum) (Datum, error)

+ EvalBitOrINetOp func(context.Context, *BitOrINetOp, Datum, Datum) (Datum, error)

+ EvalBitOrIntOp func(context.Context, *BitOrIntOp, Datum, Datum) (Datum, error)

+ EvalBitOrVarBitOp func(context.Context, *BitOrVarBitOp, Datum, Datum) (Datum, error)

+ EvalBitXorIntOp func(context.Context, *BitXorIntOp, Datum, Datum) (Datum, error)

+ EvalBitXorVarBitOp func(context.Context, *BitXorVarBitOp, Datum, Datum) (Datum, error)

+ EvalCompareBox2DOp func(context.Context, *CompareBox2DOp, Datum, Datum) (Datum, error)

+ EvalCompareScalarOp func(context.Context, *CompareScalarOp, Datum, Datum) (Datum, error)

+ EvalCompareTupleOp func(context.Context, *CompareTupleOp, Datum, Datum) (Datum, error)

+ EvalConcatArraysOp func(context.Context, *ConcatArraysOp, Datum, Datum) (Datum, error)

+ EvalConcatBytesOp func(context.Context, *ConcatBytesOp, Datum, Datum) (Datum, error)

+ EvalConcatJsonbOp func(context.Context, *ConcatJsonbOp, Datum, Datum) (Datum, error)

+ EvalConcatOp func(context.Context, *ConcatOp, Datum, Datum) (Datum, error)

+ EvalConcatStringOp func(context.Context, *ConcatStringOp, Datum, Datum) (Datum, error)

+ EvalConcatVarBitOp func(context.Context, *ConcatVarBitOp, Datum, Datum) (Datum, error)

+ EvalContainedByArrayOp func(context.Context, *ContainedByArrayOp, Datum, Datum) (Datum, error)

+ EvalContainedByJsonbOp func(context.Context, *ContainedByJsonbOp, Datum, Datum) (Datum, error)

+ EvalContainsArrayOp func(context.Context, *ContainsArrayOp, Datum, Datum) (Datum, error)

+ EvalContainsJsonbOp func(context.Context, *ContainsJsonbOp, Datum, Datum) (Datum, error)

+ EvalDivDecimalIntOp func(context.Context, *DivDecimalIntOp, Datum, Datum) (Datum, error)

+ EvalDivDecimalOp func(context.Context, *DivDecimalOp, Datum, Datum) (Datum, error)

+ EvalDivFloatOp func(context.Context, *DivFloatOp, Datum, Datum) (Datum, error)

+ EvalDivIntDecimalOp func(context.Context, *DivIntDecimalOp, Datum, Datum) (Datum, error)

+ EvalDivIntOp func(context.Context, *DivIntOp, Datum, Datum) (Datum, error)

+ EvalDivIntervalFloatOp func(context.Context, *DivIntervalFloatOp, Datum, Datum) (Datum, error)

+ EvalDivIntervalIntOp func(context.Context, *DivIntervalIntOp, Datum, Datum) (Datum, error)

+ EvalFloorDivDecimalIntOp func(context.Context, *FloorDivDecimalIntOp, Datum, Datum) (Datum, error)

+ EvalFloorDivDecimalOp func(context.Context, *FloorDivDecimalOp, Datum, Datum) (Datum, error)

+ EvalFloorDivFloatOp func(context.Context, *FloorDivFloatOp, Datum, Datum) (Datum, error)

+ EvalFloorDivIntDecimalOp func(context.Context, *FloorDivIntDecimalOp, Datum, Datum) (Datum, error)

+ EvalFloorDivIntOp func(context.Context, *FloorDivIntOp, Datum, Datum) (Datum, error)

+ EvalInTupleOp func(context.Context, *InTupleOp, Datum, Datum) (Datum, error)

+ EvalJSONAllExistsOp func(context.Context, *JSONAllExistsOp, Datum, Datum) (Datum, error)

+ EvalJSONExistsOp func(context.Context, *JSONExistsOp, Datum, Datum) (Datum, error)

+ EvalJSONFetchTextIntOp func(context.Context, *JSONFetchTextIntOp, Datum, Datum) (Datum, error)

+ EvalJSONFetchTextPathOp func(context.Context, *JSONFetchTextPathOp, Datum, Datum) (Datum, error)

+ EvalJSONFetchTextStringOp func(context.Context, *JSONFetchTextStringOp, Datum, Datum) (Datum, error)

+ EvalJSONFetchValIntOp func(context.Context, *JSONFetchValIntOp, Datum, Datum) (Datum, error)

+ EvalJSONFetchValPathOp func(context.Context, *JSONFetchValPathOp, Datum, Datum) (Datum, error)

+ EvalJSONFetchValStringOp func(context.Context, *JSONFetchValStringOp, Datum, Datum) (Datum, error)

+ EvalJSONSomeExistsOp func(context.Context, *JSONSomeExistsOp, Datum, Datum) (Datum, error)

+ EvalLShiftINetOp func(context.Context, *LShiftINetOp, Datum, Datum) (Datum, error)

+ EvalLShiftIntOp func(context.Context, *LShiftIntOp, Datum, Datum) (Datum, error)

+ EvalLShiftVarBitIntOp func(context.Context, *LShiftVarBitIntOp, Datum, Datum) (Datum, error)

+ EvalMatchLikeOp func(context.Context, *MatchLikeOp, Datum, Datum) (Datum, error)

+ EvalMatchRegexpOp func(context.Context, *MatchRegexpOp, Datum, Datum) (Datum, error)

+ EvalMinusDateIntOp func(context.Context, *MinusDateIntOp, Datum, Datum) (Datum, error)

+ EvalMinusDateIntervalOp func(context.Context, *MinusDateIntervalOp, Datum, Datum) (Datum, error)

+ EvalMinusDateOp func(context.Context, *MinusDateOp, Datum, Datum) (Datum, error)

+ EvalMinusDateTimeOp func(context.Context, *MinusDateTimeOp, Datum, Datum) (Datum, error)

+ EvalMinusDecimalIntOp func(context.Context, *MinusDecimalIntOp, Datum, Datum) (Datum, error)

+ EvalMinusDecimalOp func(context.Context, *MinusDecimalOp, Datum, Datum) (Datum, error)

+ EvalMinusFloatOp func(context.Context, *MinusFloatOp, Datum, Datum) (Datum, error)

+ EvalMinusINetIntOp func(context.Context, *MinusINetIntOp, Datum, Datum) (Datum, error)

+ EvalMinusINetOp func(context.Context, *MinusINetOp, Datum, Datum) (Datum, error)

+ EvalMinusIntDecimalOp func(context.Context, *MinusIntDecimalOp, Datum, Datum) (Datum, error)

+ EvalMinusIntOp func(context.Context, *MinusIntOp, Datum, Datum) (Datum, error)

+ EvalMinusIntervalOp func(context.Context, *MinusIntervalOp, Datum, Datum) (Datum, error)

+ EvalMinusJsonbIntOp func(context.Context, *MinusJsonbIntOp, Datum, Datum) (Datum, error)

+ EvalMinusJsonbStringArrayOp func(context.Context, *MinusJsonbStringArrayOp, Datum, Datum) (Datum, error)

+ EvalMinusJsonbStringOp func(context.Context, *MinusJsonbStringOp, Datum, Datum) (Datum, error)

+ EvalMinusPGLSNDecimalOp func(context.Context, *MinusPGLSNDecimalOp, Datum, Datum) (Datum, error)

+ EvalMinusPGLSNOp func(context.Context, *MinusPGLSNOp, Datum, Datum) (Datum, error)

+ EvalMinusTimeIntervalOp func(context.Context, *MinusTimeIntervalOp, Datum, Datum) (Datum, error)

+ EvalMinusTimeOp func(context.Context, *MinusTimeOp, Datum, Datum) (Datum, error)

+ EvalMinusTimeTZIntervalOp func(context.Context, *MinusTimeTZIntervalOp, Datum, Datum) (Datum, error)

+ EvalMinusTimestampIntervalOp func(context.Context, *MinusTimestampIntervalOp, Datum, Datum) (Datum, error)

+ EvalMinusTimestampOp func(context.Context, *MinusTimestampOp, Datum, Datum) (Datum, error)

+ EvalMinusTimestampTZIntervalOp func(context.Context, *MinusTimestampTZIntervalOp, Datum, Datum) (Datum, error)

+ EvalMinusTimestampTZOp func(context.Context, *MinusTimestampTZOp, Datum, Datum) (Datum, error)

+ EvalMinusTimestampTZTimestampOp func(context.Context, *MinusTimestampTZTimestampOp, Datum, Datum) (Datum, error)

+ EvalMinusTimestampTimestampTZOp func(context.Context, *MinusTimestampTimestampTZOp, Datum, Datum) (Datum, error)

+ EvalModDecimalIntOp func(context.Context, *ModDecimalIntOp, Datum, Datum) (Datum, error)

+ EvalModDecimalOp func(context.Context, *ModDecimalOp, Datum, Datum) (Datum, error)

+ EvalModFloatOp func(context.Context, *ModFloatOp, Datum, Datum) (Datum, error)

+ EvalModIntDecimalOp func(context.Context, *ModIntDecimalOp, Datum, Datum) (Datum, error)

+ EvalModIntOp func(context.Context, *ModIntOp, Datum, Datum) (Datum, error)

+ EvalModStringOp func(context.Context, *ModStringOp, Datum, Datum) (Datum, error)

+ EvalMultDecimalIntOp func(context.Context, *MultDecimalIntOp, Datum, Datum) (Datum, error)

+ EvalMultDecimalIntervalOp func(context.Context, *MultDecimalIntervalOp, Datum, Datum) (Datum, error)

+ EvalMultDecimalOp func(context.Context, *MultDecimalOp, Datum, Datum) (Datum, error)

+ EvalMultFloatIntervalOp func(context.Context, *MultFloatIntervalOp, Datum, Datum) (Datum, error)

+ EvalMultFloatOp func(context.Context, *MultFloatOp, Datum, Datum) (Datum, error)

+ EvalMultIntDecimalOp func(context.Context, *MultIntDecimalOp, Datum, Datum) (Datum, error)

+ EvalMultIntIntervalOp func(context.Context, *MultIntIntervalOp, Datum, Datum) (Datum, error)

+ EvalMultIntOp func(context.Context, *MultIntOp, Datum, Datum) (Datum, error)

+ EvalMultIntervalDecimalOp func(context.Context, *MultIntervalDecimalOp, Datum, Datum) (Datum, error)

+ EvalMultIntervalFloatOp func(context.Context, *MultIntervalFloatOp, Datum, Datum) (Datum, error)

+ EvalMultIntervalIntOp func(context.Context, *MultIntervalIntOp, Datum, Datum) (Datum, error)

+ EvalOverlapsArrayOp func(context.Context, *OverlapsArrayOp, Datum, Datum) (Datum, error)

+ EvalOverlapsINetOp func(context.Context, *OverlapsINetOp, Datum, Datum) (Datum, error)

+ EvalPlusDateIntOp func(context.Context, *PlusDateIntOp, Datum, Datum) (Datum, error)

+ EvalPlusDateIntervalOp func(context.Context, *PlusDateIntervalOp, Datum, Datum) (Datum, error)

+ EvalPlusDateTimeOp func(context.Context, *PlusDateTimeOp, Datum, Datum) (Datum, error)

+ EvalPlusDateTimeTZOp func(context.Context, *PlusDateTimeTZOp, Datum, Datum) (Datum, error)

+ EvalPlusDecimalIntOp func(context.Context, *PlusDecimalIntOp, Datum, Datum) (Datum, error)

+ EvalPlusDecimalOp func(context.Context, *PlusDecimalOp, Datum, Datum) (Datum, error)

+ EvalPlusDecimalPGLSNOp func(context.Context, *PlusDecimalPGLSNOp, Datum, Datum) (Datum, error)

+ EvalPlusFloatOp func(context.Context, *PlusFloatOp, Datum, Datum) (Datum, error)

+ EvalPlusINetIntOp func(context.Context, *PlusINetIntOp, Datum, Datum) (Datum, error)

+ EvalPlusIntDateOp func(context.Context, *PlusIntDateOp, Datum, Datum) (Datum, error)

+ EvalPlusIntDecimalOp func(context.Context, *PlusIntDecimalOp, Datum, Datum) (Datum, error)

+ EvalPlusIntINetOp func(context.Context, *PlusIntINetOp, Datum, Datum) (Datum, error)

+ EvalPlusIntOp func(context.Context, *PlusIntOp, Datum, Datum) (Datum, error)

+ EvalPlusIntervalDateOp func(context.Context, *PlusIntervalDateOp, Datum, Datum) (Datum, error)

+ EvalPlusIntervalOp func(context.Context, *PlusIntervalOp, Datum, Datum) (Datum, error)

+ EvalPlusIntervalTimeOp func(context.Context, *PlusIntervalTimeOp, Datum, Datum) (Datum, error)

+ EvalPlusIntervalTimeTZOp func(context.Context, *PlusIntervalTimeTZOp, Datum, Datum) (Datum, error)

+ EvalPlusIntervalTimestampOp func(context.Context, *PlusIntervalTimestampOp, Datum, Datum) (Datum, error)

+ EvalPlusIntervalTimestampTZOp func(context.Context, *PlusIntervalTimestampTZOp, Datum, Datum) (Datum, error)

+ EvalPlusPGLSNDecimalOp func(context.Context, *PlusPGLSNDecimalOp, Datum, Datum) (Datum, error)

+ EvalPlusTimeDateOp func(context.Context, *PlusTimeDateOp, Datum, Datum) (Datum, error)

+ EvalPlusTimeIntervalOp func(context.Context, *PlusTimeIntervalOp, Datum, Datum) (Datum, error)

+ EvalPlusTimeTZDateOp func(context.Context, *PlusTimeTZDateOp, Datum, Datum) (Datum, error)

+ EvalPlusTimeTZIntervalOp func(context.Context, *PlusTimeTZIntervalOp, Datum, Datum) (Datum, error)

+ EvalPlusTimestampIntervalOp func(context.Context, *PlusTimestampIntervalOp, Datum, Datum) (Datum, error)

+ EvalPlusTimestampTZIntervalOp func(context.Context, *PlusTimestampTZIntervalOp, Datum, Datum) (Datum, error)

+ EvalPowDecimalIntOp func(context.Context, *PowDecimalIntOp, Datum, Datum) (Datum, error)

+ EvalPowDecimalOp func(context.Context, *PowDecimalOp, Datum, Datum) (Datum, error)

+ EvalPowFloatOp func(context.Context, *PowFloatOp, Datum, Datum) (Datum, error)

+ EvalPowIntDecimalOp func(context.Context, *PowIntDecimalOp, Datum, Datum) (Datum, error)

+ EvalPowIntOp func(context.Context, *PowIntOp, Datum, Datum) (Datum, error)

+ EvalPrependToMaybeNullArrayOp func(context.Context, *PrependToMaybeNullArrayOp, Datum, Datum) (Datum, error)

+ EvalRShiftINetOp func(context.Context, *RShiftINetOp, Datum, Datum) (Datum, error)

+ EvalRShiftIntOp func(context.Context, *RShiftIntOp, Datum, Datum) (Datum, error)

+ EvalRShiftVarBitIntOp func(context.Context, *RShiftVarBitIntOp, Datum, Datum) (Datum, error)

+ EvalTSMatchesQueryVectorOp func(context.Context, *TSMatchesQueryVectorOp, Datum, Datum) (Datum, error)

+ EvalTSMatchesVectorQueryOp func(context.Context, *TSMatchesVectorQueryOp, Datum, Datum) (Datum, error)

+ type BitAndINetOp struct

+ func (op *BitAndINetOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type BitAndIntOp struct

+ func (op *BitAndIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type BitAndVarBitOp struct

+ func (op *BitAndVarBitOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type BitOrINetOp struct

+ func (op *BitOrINetOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type BitOrIntOp struct

+ func (op *BitOrIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type BitOrVarBitOp struct

+ func (op *BitOrVarBitOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type BitXorIntOp struct

+ func (op *BitXorIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type BitXorVarBitOp struct

+ func (op *BitXorVarBitOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type BlockState struct

+ Cursors []Name

+ ExceptionHandler *RoutineExceptionHandler

+ SavepointTok interface{}

+ type CCLOnlyStatement interface

+ type CTE struct

+ Mtr CTEMaterializeClause

+ Name AliasClause

+ Stmt Statement

+ type CTEMaterializeClause int8

+ const CTEMaterializeAlways

+ const CTEMaterializeDefault

+ const CTEMaterializeNever

+ type Call struct

+ Proc *FuncExpr

+ func (*Call) StatementReturnType() StatementReturnType

+ func (*Call) StatementTag() string

+ func (*Call) StatementType() StatementType

+ func (n *Call) String() string

+ func (node *Call) Format(ctx *FmtCtx)

+ type CancelQueries struct

+ IfExists bool

+ Queries *Select

+ func (*CancelQueries) StatementReturnType() StatementReturnType

+ func (*CancelQueries) StatementTag() string

+ func (*CancelQueries) StatementType() StatementType

+ func (n *CancelQueries) String() string

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

+ type CancelSessions struct

+ IfExists bool

+ Sessions *Select

+ func (*CancelSessions) StatementReturnType() StatementReturnType

+ func (*CancelSessions) StatementTag() string

+ func (*CancelSessions) StatementType() StatementType

+ func (n *CancelSessions) String() string

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

+ type CannedOptPlan struct

+ Plan string

+ func (*CannedOptPlan) StatementReturnType() StatementReturnType

+ func (*CannedOptPlan) StatementTag() string

+ func (*CannedOptPlan) StatementType() StatementType

+ func (n *CannedOptPlan) String() string

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

+ type CaseExpr struct

+ Else Expr

+ Expr Expr

+ Whens []*When

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

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

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

+ func (node *CaseExpr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

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

+ func (node *CaseExpr) String() string

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

+ type CaseMode int

+ const LowerCase

+ const UpperCase

+ type CastCounterType struct

+ From types.Family

+ To types.Family

+ type CastExpr struct

+ Expr Expr

+ SyntaxMode castSyntaxMode

+ Type ResolvableTypeReference

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

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

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

+ func (node *CastExpr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

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

+ func (node *CastExpr) String() string

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

+ type CbrtDecimalOp struct

+ func (op *CbrtDecimalOp) Eval(ctx context.Context, e OpEvaluator, v Datum) (Datum, error)

+ type CbrtFloatOp struct

+ func (op *CbrtFloatOp) Eval(ctx context.Context, e OpEvaluator, v Datum) (Datum, error)

+ type ChangefeedTarget struct

+ FamilyName Name

+ TableName TablePattern

+ func ChangefeedTargetFromTableExpr(e TableExpr) (ChangefeedTarget, error)

+ func (ct *ChangefeedTarget) Format(ctx *FmtCtx)

+ type ChangefeedTargets []ChangefeedTarget

+ func (cts *ChangefeedTargets) Format(ctx *FmtCtx)

+ type CheckConstraintTableDef struct

+ Expr Expr

+ FromHashShardedColumn bool

+ IfNotExists bool

+ Name Name

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

+ func (node *CheckConstraintTableDef) SetIfNotExists()

+ func (node *CheckConstraintTableDef) SetName(name Name)

+ type CloseCursor struct

+ All bool

+ Name Name

+ func (*CloseCursor) StatementReturnType() StatementReturnType

+ func (*CloseCursor) StatementTag() string

+ func (*CloseCursor) StatementType() StatementType

+ func (c CloseCursor) Format(ctx *FmtCtx)

+ func (n *CloseCursor) String() string

+ type CmpOp struct

+ CalledOnNullInput bool

+ EvalOp BinaryEvalOp

+ LeftType *types.T

+ OnTypeCheck func()

+ PreferredOverload bool

+ RightType *types.T

+ Volatility volatility.V

+ type CmpOpOverloads struct

+ func (o *CmpOpOverloads) ForEachCmpOp(f func(op *CmpOp) error) error

+ func (o *CmpOpOverloads) LookupImpl(left, right *types.T) (*CmpOp, bool)

+ type CoalesceExpr struct

+ Exprs Exprs

+ Name string

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

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

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

+ func (node *CoalesceExpr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

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

+ func (node *CoalesceExpr) GetWhenCondition(i int) (whenCond Expr)

+ func (node *CoalesceExpr) String() string

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

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

+ type CollateExpr struct

+ Expr Expr

+ Locale string

+ func NewTypedCollateExpr(expr TypedExpr, locale string) *CollateExpr

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

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

+ func (node *CollateExpr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

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

+ func (node *CollateExpr) String() string

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

+ type CollationEnvironment struct

+ type ColumnAccessExpr struct

+ ByIndex bool

+ ColIndex int

+ ColName Name

+ Expr Expr

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

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

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

+ func (node *ColumnAccessExpr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

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

+ func (node *ColumnAccessExpr) String() string

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

+ type ColumnCheckConstraint struct

+ Expr Expr

+ type ColumnCollation string

+ type ColumnComputedDef struct

+ Expr Expr

+ Virtual bool

+ type ColumnDef struct

+ Name Name

+ Type ResolvableTypeReference

+ func (c *ColumnDef) Format(ctx *FmtCtx)

+ type ColumnDefList []ColumnDef

+ func (c *ColumnDefList) Format(ctx *FmtCtx)

+ type ColumnDefault struct

+ Expr Expr

+ type ColumnFKConstraint struct

+ Actions ReferenceActions

+ Col Name

+ Match CompositeKeyMatchMethod

+ Table TableName

+ type ColumnFamilyConstraint struct

+ Create bool

+ Family Name

+ IfNotExists bool

+ type ColumnID = catid.ColumnID

+ type ColumnItem struct

+ ColumnName Name

+ TableName *UnresolvedObjectName

+ func MakeColumnItem(tn *TableName, colName Name) ColumnItem

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

+ func (c *ColumnItem) Column() string

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

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

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

+ func (c *ColumnItem) String() string

+ func (c *ColumnItem) Variable()

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

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

+ func (node *ColumnItem) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ type ColumnMutationCmd interface

+ GetColumn func() Name

+ type ColumnOnUpdate struct

+ Expr Expr

+ type ColumnQualification interface

+ type ColumnTableDef struct

+ CheckExprs []ColumnTableDefCheckExpr

+ Computed struct{ ... }

+ DefaultExpr struct{ ... }

+ Family struct{ ... }

+ GeneratedIdentity struct{ ... }

+ Hidden bool

+ IsCreateAs bool

+ IsSerial bool

+ Name Name

+ Nullable struct{ ... }

+ OnUpdateExpr struct{ ... }

+ PrimaryKey struct{ ... }

+ References struct{ ... }

+ Type ResolvableTypeReference

+ Unique struct{ ... }

+ func NewColumnTableDef(name Name, typRef ResolvableTypeReference, isSerial bool, ...) (*ColumnTableDef, error)

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

+ func (node *ColumnTableDef) HasColumnFamily() bool

+ func (node *ColumnTableDef) HasDefaultExpr() bool

+ func (node *ColumnTableDef) HasFKConstraint() bool

+ func (node *ColumnTableDef) HasOnUpdateExpr() bool

+ func (node *ColumnTableDef) IsComputed() bool

+ func (node *ColumnTableDef) IsVirtual() bool

+ func (node *ColumnTableDef) String() string

+ type ColumnTableDefCheckExpr struct

+ ConstraintName Name

+ Expr Expr

+ type CommentOnColumn struct

+ Comment *string

+ func (*CommentOnColumn) StatementReturnType() StatementReturnType

+ func (*CommentOnColumn) StatementTag() string

+ func (*CommentOnColumn) StatementType() StatementType

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

+ func (n *CommentOnColumn) String() string

+ type CommentOnConstraint struct

+ Comment *string

+ Constraint Name

+ Table *UnresolvedObjectName

+ func (*CommentOnConstraint) StatementReturnType() StatementReturnType

+ func (*CommentOnConstraint) StatementTag() string

+ func (*CommentOnConstraint) StatementType() StatementType

+ func (n *CommentOnConstraint) Format(ctx *FmtCtx)

+ func (n *CommentOnConstraint) String() string

+ type CommentOnDatabase struct

+ Comment *string

+ Name Name

+ func (*CommentOnDatabase) StatementReturnType() StatementReturnType

+ func (*CommentOnDatabase) StatementTag() string

+ func (*CommentOnDatabase) StatementType() StatementType

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

+ func (n *CommentOnDatabase) String() string

+ type CommentOnIndex struct

+ Comment *string

+ Index TableIndexName

+ func (*CommentOnIndex) StatementReturnType() StatementReturnType

+ func (*CommentOnIndex) StatementTag() string

+ func (*CommentOnIndex) StatementType() StatementType

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

+ func (n *CommentOnIndex) String() string

+ type CommentOnSchema struct

+ Comment *string

+ Name ObjectNamePrefix

+ func (*CommentOnSchema) StatementReturnType() StatementReturnType

+ func (*CommentOnSchema) StatementTag() string

+ func (*CommentOnSchema) StatementType() StatementType

+ func (n *CommentOnSchema) Format(ctx *FmtCtx)

+ func (n *CommentOnSchema) String() string

+ type CommentOnTable struct

+ Comment *string

+ Table *UnresolvedObjectName

+ func (*CommentOnTable) StatementReturnType() StatementReturnType

+ func (*CommentOnTable) StatementTag() string

+ func (*CommentOnTable) StatementType() StatementType

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

+ func (n *CommentOnTable) String() string

+ type CommitTransaction struct

+ func (*CommitTransaction) StatementReturnType() StatementReturnType

+ func (*CommitTransaction) StatementTag() string

+ func (*CommitTransaction) StatementType() StatementType

+ func (n *CommitTransaction) String() string

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

+ type CompareAnyTupleOp CompareTupleOp

+ func (t *CompareAnyTupleOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type CompareBox2DOp struct

+ Op func(left, right Datum) bool

+ func (op *CompareBox2DOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type CompareContext interface

+ GetLocation func() *time.Location

+ GetRelativeParseTime func() time.Time

+ MustGetPlaceholderValue func(p *Placeholder) Datum

+ UnwrapDatum func(d Datum) Datum

+ type CompareScalarOp struct

+ func (op *CompareScalarOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type CompareTupleOp struct

+ func (op *CompareTupleOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type ComparisonExpr struct

+ Left Expr

+ Op *CmpOp

+ Operator treecmp.ComparisonOperator

+ Right Expr

+ SubOperator treecmp.ComparisonOperator

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

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

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

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

+ func (node *ComparisonExpr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

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

+ func (node *ComparisonExpr) String() string

+ func (node *ComparisonExpr) TypedLeft() TypedExpr

+ func (node *ComparisonExpr) TypedRight() TypedExpr

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

+ type ComplementINetOp struct

+ func (op *ComplementINetOp) Eval(ctx context.Context, e OpEvaluator, v Datum) (Datum, error)

+ type ComplementIntOp struct

+ func (op *ComplementIntOp) Eval(ctx context.Context, e OpEvaluator, v Datum) (Datum, error)

+ type ComplementVarBitOp struct

+ func (op *ComplementVarBitOp) Eval(ctx context.Context, e OpEvaluator, v Datum) (Datum, error)

+ type CompositeDatum interface

+ IsComposite func() bool

+ type CompositeKeyMatchMethod semenumpb.Match

+ const MatchFull

+ const MatchPartial

+ const MatchSimple

+ func (x CompositeKeyMatchMethod) String() string

+ type CompositeTypeElem struct

+ Label Name

+ Type ResolvableTypeReference

+ type ConcatArraysOp struct

+ Typ *types.T

+ func (op *ConcatArraysOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type ConcatBytesOp struct

+ func (op *ConcatBytesOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type ConcatJsonbOp struct

+ func (op *ConcatJsonbOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type ConcatOp struct

+ Left *types.T

+ Right *types.T

+ func (op *ConcatOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type ConcatStringOp struct

+ func (op *ConcatStringOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type ConcatVarBitOp struct

+ func (op *ConcatVarBitOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type Constant interface

+ AvailableTypes func() []*types.T

+ DesirableTypes func() []*types.T

+ ResolveAsType func(context.Context, *SemaContext, *types.T) (TypedExpr, error)

+ type ConstraintTableDef interface

+ SetIfNotExists func()

+ SetName func(name Name)

+ type ContainedByArrayOp struct

+ func (op *ContainedByArrayOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type ContainedByJsonbOp struct

+ func (op *ContainedByJsonbOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type ContainsArrayOp struct

+ func (op *ContainsArrayOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type ContainsJsonbOp struct

+ func (op *ContainsJsonbOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type ControlJobs struct

+ Command JobCommand

+ Jobs *Select

+ Reason Expr

+ func (*ControlJobs) StatementReturnType() StatementReturnType

+ func (*ControlJobs) StatementType() StatementType

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

+ func (n *ControlJobs) StatementTag() string

+ func (n *ControlJobs) String() string

+ type ControlJobsForSchedules struct

+ Command JobCommand

+ Schedules *Select

+ func (*ControlJobsForSchedules) StatementReturnType() StatementReturnType

+ func (*ControlJobsForSchedules) StatementType() StatementType

+ func (n *ControlJobsForSchedules) Format(ctx *FmtCtx)

+ func (n *ControlJobsForSchedules) StatementTag() string

+ func (n *ControlJobsForSchedules) String() string

+ type ControlJobsOfType struct

+ Command JobCommand

+ Type string

+ func (*ControlJobsOfType) StatementReturnType() StatementReturnType

+ func (*ControlJobsOfType) StatementType() StatementType

+ func (n *ControlJobsOfType) Format(ctx *FmtCtx)

+ func (n *ControlJobsOfType) StatementTag() string

+ func (n *ControlJobsOfType) String() string

+ type ControlSchedules struct

+ Command ScheduleCommand

+ Schedules *Select

+ func (*ControlSchedules) StatementReturnType() StatementReturnType

+ func (*ControlSchedules) StatementType() StatementType

+ func (n *ControlSchedules) Format(ctx *FmtCtx)

+ func (n *ControlSchedules) StatementTag() string

+ func (n *ControlSchedules) String() string

+ type CopyFormat int

+ const CopyFormatBinary

+ const CopyFormatCSV

+ const CopyFormatText

+ type CopyFrom struct

+ Columns NameList

+ Options CopyOptions

+ Stdin bool

+ Table TableName

+ func (*CopyFrom) StatementReturnType() StatementReturnType

+ func (*CopyFrom) StatementTag() string

+ func (*CopyFrom) StatementType() StatementType

+ func (n *CopyFrom) String() string

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

+ type CopyOptions struct

+ CopyFormat CopyFormat

+ Delimiter Expr

+ Destination Expr

+ Escape *StrVal

+ HasFormat bool

+ HasHeader bool

+ Header bool

+ Null Expr

+ Quote *StrVal

+ func (o *CopyOptions) CombineWith(other *CopyOptions) error

+ func (o *CopyOptions) Format(ctx *FmtCtx)

+ func (o CopyOptions) IsDefault() bool

+ type CopyTo struct

+ Columns NameList

+ Options CopyOptions

+ Statement Statement

+ Table TableName

+ func (*CopyTo) StatementReturnType() StatementReturnType

+ func (*CopyTo) StatementTag() string

+ func (*CopyTo) StatementType() StatementType

+ func (n *CopyTo) String() string

+ func (node *CopyTo) Format(ctx *FmtCtx)

+ type CreateChangefeed struct

+ Options KVOptions

+ Select *SelectClause

+ SinkURI Expr

+ Targets ChangefeedTargets

+ func (*CreateChangefeed) StatementReturnType() StatementReturnType

+ func (*CreateChangefeed) StatementType() StatementType

+ func (n *CreateChangefeed) StatementTag() string

+ func (n *CreateChangefeed) String() string

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

+ type CreateDatabase struct

+ CType string

+ Collate string

+ ConnectionLimit int32

+ Encoding string

+ IfNotExists bool

+ Name Name

+ Owner RoleSpec

+ Placement DataPlacement

+ PrimaryRegion Name

+ Regions NameList

+ SecondaryRegion Name

+ SuperRegion SuperRegion

+ SurvivalGoal SurvivalGoal

+ Template string

+ func (*CreateDatabase) StatementReturnType() StatementReturnType

+ func (*CreateDatabase) StatementTag() string

+ func (*CreateDatabase) StatementType() StatementType

+ func (n *CreateDatabase) String() string

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

+ type CreateExtension struct

+ IfNotExists bool

+ Name Name

+ func (*CreateExtension) StatementReturnType() StatementReturnType

+ func (*CreateExtension) StatementTag() string

+ func (*CreateExtension) StatementType() StatementType

+ func (n *CreateExtension) String() string

+ func (node *CreateExtension) Format(ctx *FmtCtx)

+ type CreateExternalConnection struct

+ As Expr

+ ConnectionLabelSpec LabelSpec

+ func (*CreateExternalConnection) StatementReturnType() StatementReturnType

+ func (*CreateExternalConnection) StatementTag() string

+ func (*CreateExternalConnection) StatementType() StatementType

+ func (n *CreateExternalConnection) String() string

+ func (node *CreateExternalConnection) Format(ctx *FmtCtx)

+ type CreateIndex struct

+ Columns IndexElemList

+ Concurrently bool

+ IfNotExists bool

+ Inverted bool

+ Invisibility IndexInvisibility

+ Name Name

+ PartitionByIndex *PartitionByIndex

+ Predicate Expr

+ Sharded *ShardedIndexDef

+ StorageParams StorageParams

+ Storing NameList

+ Table TableName

+ Unique bool

+ func (*CreateIndex) StatementReturnType() StatementReturnType

+ func (*CreateIndex) StatementTag() string

+ func (*CreateIndex) StatementType() StatementType

+ func (n *CreateIndex) String() string

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

+ type CreateRole struct

+ IfNotExists bool

+ IsRole bool

+ KVOptions KVOptions

+ Name RoleSpec

+ func (*CreateRole) StatementReturnType() StatementReturnType

+ func (*CreateRole) StatementTag() string

+ func (*CreateRole) StatementType() StatementType

+ func (n *CreateRole) String() string

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

+ type CreateRoutine struct

+ BodyAnnotations []*Annotations

+ BodyStatements Statements

+ IsProcedure bool

+ Name RoutineName

+ Options RoutineOptions

+ Params RoutineParams

+ Replace bool

+ ReturnType RoutineReturnType

+ RoutineBody *RoutineBody

+ func (*CreateRoutine) StatementReturnType() StatementReturnType

+ func (*CreateRoutine) StatementType() StatementType

+ func (n *CreateRoutine) StatementTag() string

+ func (n *CreateRoutine) String() string

+ func (node *CreateRoutine) Format(ctx *FmtCtx)

+ type CreateSchema struct

+ AuthRole RoleSpec

+ IfNotExists bool

+ Schema ObjectNamePrefix

+ func (*CreateSchema) StatementType() StatementType

+ func (n *CreateSchema) StatementReturnType() StatementReturnType

+ func (n *CreateSchema) StatementTag() string

+ func (n *CreateSchema) String() string

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

+ type CreateSequence struct

+ IfNotExists bool

+ Name TableName

+ Options SequenceOptions

+ Persistence Persistence

+ func (*CreateSequence) StatementReturnType() StatementReturnType

+ func (*CreateSequence) StatementTag() string

+ func (*CreateSequence) StatementType() StatementType

+ func (n *CreateSequence) String() string

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

+ type CreateStats struct

+ ColumnNames NameList

+ Name Name

+ Options CreateStatsOptions

+ Table TableExpr

+ func (*CreateStats) StatementReturnType() StatementReturnType

+ func (*CreateStats) StatementTag() string

+ func (*CreateStats) StatementType() StatementType

+ func (n *CreateStats) String() string

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

+ type CreateStatsOptions struct

+ AsOf AsOfClause

+ Throttling float64

+ UsingExtremes bool

+ Where *Where

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

+ func (o *CreateStatsOptions) Empty() bool

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

+ type CreateTable struct

+ AsSource *Select

+ Defs TableDefs

+ IfNotExists bool

+ Locality *Locality

+ OnCommit CreateTableOnCommitSetting

+ PartitionByTable *PartitionByTable

+ Persistence Persistence

+ StorageParams StorageParams

+ Table TableName

+ func (*CreateTable) StatementType() StatementType

+ func (n *CreateTable) StatementReturnType() StatementReturnType

+ func (n *CreateTable) StatementTag() string

+ func (n *CreateTable) String() string

+ func (node *CreateTable) As() bool

+ func (node *CreateTable) AsHasUserSpecifiedPrimaryKey() bool

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

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

+ func (node *CreateTable) HoistConstraints()

+ type CreateTableOnCommitSetting uint32

+ const CreateTableOnCommitPreserveRows

+ const CreateTableOnCommitUnset

+ type CreateTenant struct

+ IfNotExists bool

+ Like *LikeTenantSpec

+ TenantSpec *TenantSpec

+ func (*CreateTenant) StatementReturnType() StatementReturnType

+ func (*CreateTenant) StatementTag() string

+ func (*CreateTenant) StatementType() StatementType

+ func (n *CreateTenant) String() string

+ func (node *CreateTenant) Format(ctx *FmtCtx)

+ type CreateTenantFromReplication struct

+ IfNotExists bool

+ Like *LikeTenantSpec

+ Options TenantReplicationOptions

+ ReplicationSourceAddress Expr

+ ReplicationSourceTenantName *TenantSpec

+ TenantSpec *TenantSpec

+ func (*CreateTenantFromReplication) StatementReturnType() StatementReturnType

+ func (*CreateTenantFromReplication) StatementTag() string

+ func (*CreateTenantFromReplication) StatementType() StatementType

+ func (n *CreateTenantFromReplication) String() string

+ func (node *CreateTenantFromReplication) Format(ctx *FmtCtx)

+ type CreateType struct

+ CompositeTypeList []CompositeTypeElem

+ EnumLabels EnumValueList

+ IfNotExists bool

+ TypeName *UnresolvedObjectName

+ Variety CreateTypeVariety

+ func (*CreateType) StatementReturnType() StatementReturnType

+ func (*CreateType) StatementTag() string

+ func (*CreateType) StatementType() StatementType

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

+ func (node *CreateType) String() string

+ type CreateTypeVariety int

+ const Base

+ const Composite

+ const Domain

+ const Enum

+ const Range

+ const Shell

+ func (i CreateTypeVariety) String() string

+ type CreateView struct

+ AsSource *Select

+ ColumnNames NameList

+ IfNotExists bool

+ Materialized bool

+ Name TableName

+ Persistence Persistence

+ Replace bool

+ WithData bool

+ func (*CreateView) StatementReturnType() StatementReturnType

+ func (*CreateView) StatementTag() string

+ func (*CreateView) StatementType() StatementType

+ func (n *CreateView) String() string

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

+ type CursorScrollOption int8

+ const NoScroll

+ const Scroll

+ const UnspecifiedScroll

+ func (o CursorScrollOption) String() string

+ type CursorSensitivity int

+ const Asensitive

+ const Insensitive

+ const UnspecifiedSensitivity

+ func (o CursorSensitivity) String() string

+ type CursorStmt struct

+ Count int64

+ FetchType FetchType

+ Name Name

+ func (c CursorStmt) Format(ctx *FmtCtx)

+ type DArray struct

+ Array Datums

+ HasNonNulls bool

+ HasNulls bool

+ ParamTyp *types.T

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

+ func MustBeDArray(e Expr) *DArray

+ func NewDArray(paramTyp *types.T) *DArray

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

+ func (d *DArray) AmbiguousFormat() bool

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

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

+ func (d *DArray) CompareError(ctx CompareContext, other Datum) (int, error)

+ func (d *DArray) FirstIndex() int

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

+ func (d *DArray) IsComposite() bool

+ func (d *DArray) IsMax(ctx CompareContext) bool

+ func (d *DArray) IsMin(ctx CompareContext) bool

+ func (d *DArray) Len() int

+ func (d *DArray) Max(ctx CompareContext) (Datum, bool)

+ func (d *DArray) MaybeSetCustomOid(t *types.T) error

+ func (d *DArray) Min(ctx CompareContext) (Datum, bool)

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

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

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

+ func (d *DArray) Size() uintptr

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

+ func (d *DArray) Validate() error

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

+ func (node *DArray) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DArray) String() string

+ type DBitArray struct

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

+ func FormatBitArrayToType(d *DBitArray, t *types.T) *DBitArray

+ func MakeDBitArray(bitLen uint) DBitArray

+ func MustBeDBitArray(e Expr) *DBitArray

+ func NewDBitArray(bitLen uint) *DBitArray

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

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

+ func (*DBitArray) AmbiguousFormat() bool

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

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

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

+ func (d *DBitArray) CompareError(ctx CompareContext, other Datum) (int, error)

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

+ func (d *DBitArray) IsMax(ctx CompareContext) bool

+ func (d *DBitArray) IsMin(ctx CompareContext) bool

+ func (d *DBitArray) Max(ctx CompareContext) (Datum, bool)

+ func (d *DBitArray) Min(ctx CompareContext) (Datum, bool)

+ func (d *DBitArray) Next(ctx CompareContext) (Datum, bool)

+ func (d *DBitArray) Prev(ctx CompareContext) (Datum, bool)

+ func (d *DBitArray) Size() uintptr

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

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

+ func (node *DBitArray) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DBitArray) String() string

+ type DBool bool

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

+ func ArrayOverlaps(ctx CompareContext, array, other *DArray) (*DBool, error)

+ func AsDBool(e Expr) (DBool, bool)

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

+ func JSONExistsAny(json DJSON, dArray *DArray) (*DBool, error)

+ func MakeDBool(d DBool) *DBool

+ func MustBeDBool(e Expr) DBool

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

+ func (*DBool) AmbiguousFormat() bool

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

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

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

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

+ func (d *DBool) CompareError(ctx CompareContext, other Datum) (int, error)

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

+ func (d *DBool) IsMax(ctx CompareContext) bool

+ func (d *DBool) IsMin(ctx CompareContext) bool

+ func (d *DBool) Max(ctx CompareContext) (Datum, bool)

+ func (d *DBool) Min(ctx CompareContext) (Datum, bool)

+ func (d *DBool) Size() uintptr

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

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

+ func (node *DBool) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DBool) String() string

+ type DBox2D struct

+ func AsDBox2D(e Expr) (*DBox2D, bool)

+ func MustBeDBox2D(e Expr) *DBox2D

+ func NewDBox2D(b geo.CartesianBoundingBox) *DBox2D

+ func ParseDBox2D(str string) (*DBox2D, error)

+ func (*DBox2D) AmbiguousFormat() bool

+ func (*DBox2D) ResolvedType() *types.T

+ func (d *DBox2D) Compare(ctx CompareContext, other Datum) int

+ func (d *DBox2D) CompareError(ctx CompareContext, other Datum) (int, error)

+ func (d *DBox2D) Format(ctx *FmtCtx)

+ func (d *DBox2D) IsMax(ctx CompareContext) bool

+ func (d *DBox2D) IsMin(ctx CompareContext) bool

+ func (d *DBox2D) Max(ctx CompareContext) (Datum, bool)

+ func (d *DBox2D) Min(ctx CompareContext) (Datum, bool)

+ func (d *DBox2D) Next(ctx CompareContext) (Datum, bool)

+ func (d *DBox2D) Prev(ctx CompareContext) (Datum, bool)

+ func (d *DBox2D) Size() uintptr

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

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

+ func (node *DBox2D) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DBox2D) String() string

+ type DBytes string

+ func AsDBytes(e Expr) (DBytes, bool)

+ func MustBeDBytes(e Expr) DBytes

+ func NewDBytes(d DBytes) *DBytes

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

+ func (*DBytes) AmbiguousFormat() bool

+ func (*DBytes) IsMax(ctx CompareContext) bool

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

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

+ func (d *DBytes) CompareError(ctx CompareContext, other Datum) (int, error)

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

+ func (d *DBytes) IsMin(ctx CompareContext) bool

+ func (d *DBytes) Max(ctx CompareContext) (Datum, bool)

+ func (d *DBytes) Min(ctx CompareContext) (Datum, bool)

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

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

+ func (d *DBytes) Size() uintptr

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

+ func (d *DBytes) UnsafeBytes() []byte

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

+ func (node *DBytes) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DBytes) String() string

+ type DCollatedString struct

+ Contents string

+ Key []byte

+ Locale string

+ func AsDCollatedString(e Expr) (DCollatedString, bool)

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

+ func (*DCollatedString) AmbiguousFormat() bool

+ func (*DCollatedString) IsMax(ctx CompareContext) bool

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

+ func (d *DCollatedString) CompareError(ctx CompareContext, other Datum) (int, error)

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

+ func (d *DCollatedString) IsComposite() bool

+ func (d *DCollatedString) IsMin(ctx CompareContext) bool

+ func (d *DCollatedString) Max(ctx CompareContext) (Datum, bool)

+ func (d *DCollatedString) Min(ctx CompareContext) (Datum, bool)

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

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

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

+ func (d *DCollatedString) Size() uintptr

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

+ func (d *DCollatedString) UnsafeContentBytes() []byte

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

+ func (node *DCollatedString) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DCollatedString) String() string

+ type DDate struct

+ func AsDDate(e Expr) (DDate, bool)

+ func MakeDDate(d pgdate.Date) DDate

+ func MustBeDDate(e Expr) DDate

+ func NewDDate(d pgdate.Date) *DDate

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

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

+ func (*DDate) AmbiguousFormat() bool

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

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

+ func (d *DDate) CompareError(ctx CompareContext, other Datum) (int, error)

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

+ func (d *DDate) IsMax(ctx CompareContext) bool

+ func (d *DDate) IsMin(ctx CompareContext) bool

+ func (d *DDate) Max(ctx CompareContext) (Datum, bool)

+ func (d *DDate) Min(ctx CompareContext) (Datum, bool)

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

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

+ func (d *DDate) Size() uintptr

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

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

+ func (node *DDate) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DDate) String() string

+ type DDecimal struct

+ var DecimalOne DDecimal

+ func AsDDecimal(e Expr) (*DDecimal, bool)

+ func MustBeDDecimal(e Expr) DDecimal

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

+ func (*DDecimal) AmbiguousFormat() bool

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

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

+ func (d *DDecimal) CompareError(ctx CompareContext, other Datum) (int, error)

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

+ func (d *DDecimal) IsComposite() bool

+ func (d *DDecimal) IsMax(ctx CompareContext) bool

+ func (d *DDecimal) IsMin(ctx CompareContext) bool

+ func (d *DDecimal) Max(ctx CompareContext) (Datum, bool)

+ func (d *DDecimal) Min(ctx CompareContext) (Datum, bool)

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

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

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

+ func (d *DDecimal) Size() uintptr

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

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

+ func (node *DDecimal) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DDecimal) String() string

+ type DEncodedKey string

+ func NewDEncodedKey(d DEncodedKey) *DEncodedKey

+ func (*DEncodedKey) AmbiguousFormat() bool

+ func (*DEncodedKey) IsMax(ctx CompareContext) bool

+ func (*DEncodedKey) ResolvedType() *types.T

+ func (d *DEncodedKey) Compare(ctx CompareContext, other Datum) int

+ func (d *DEncodedKey) CompareError(ctx CompareContext, other Datum) (int, error)

+ func (d *DEncodedKey) Format(ctx *FmtCtx)

+ func (d *DEncodedKey) IsMin(ctx CompareContext) bool

+ func (d *DEncodedKey) Max(ctx CompareContext) (Datum, bool)

+ func (d *DEncodedKey) Min(ctx CompareContext) (Datum, bool)

+ func (d *DEncodedKey) Next(ctx CompareContext) (Datum, bool)

+ func (d *DEncodedKey) Prev(ctx CompareContext) (Datum, bool)

+ func (d *DEncodedKey) Size() uintptr

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

+ func (d *DEncodedKey) UnsafeBytes() []byte

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

+ func (node *DEncodedKey) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DEncodedKey) String() string

+ type DEnum struct

+ EnumTyp *types.T

+ LogicalRep string

+ PhysicalRep []byte

+ func AsDEnum(e Expr) (*DEnum, bool)

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

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

+ func NewDEnum(e DEnum) *DEnum

+ func (d *DEnum) AmbiguousFormat() bool

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

+ func (d *DEnum) CompareError(ctx CompareContext, other Datum) (int, error)

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

+ func (d *DEnum) IsMax(ctx CompareContext) bool

+ func (d *DEnum) IsMin(ctx CompareContext) bool

+ func (d *DEnum) Max(ctx CompareContext) (Datum, bool)

+ func (d *DEnum) MaxWriteable() (Datum, bool)

+ func (d *DEnum) Min(ctx CompareContext) (Datum, bool)

+ func (d *DEnum) MinWriteable() (Datum, bool)

+ func (d *DEnum) Next(ctx CompareContext) (Datum, bool)

+ func (d *DEnum) Prev(ctx CompareContext) (Datum, bool)

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

+ func (d *DEnum) Size() uintptr

+ func (d *DEnum) String() string

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

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

+ func (node *DEnum) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ type DFloat float64

+ func AsDFloat(e Expr) (*DFloat, bool)

+ func MustBeDFloat(e Expr) DFloat

+ func NewDFloat(d DFloat) *DFloat

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

+ func (*DFloat) AmbiguousFormat() bool

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

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

+ func (d *DFloat) CompareError(ctx CompareContext, other Datum) (int, error)

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

+ func (d *DFloat) IsComposite() bool

+ func (d *DFloat) IsMax(ctx CompareContext) bool

+ func (d *DFloat) IsMin(ctx CompareContext) bool

+ func (d *DFloat) Max(ctx CompareContext) (Datum, bool)

+ func (d *DFloat) Min(ctx CompareContext) (Datum, bool)

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

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

+ func (d *DFloat) Size() uintptr

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

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

+ func (node *DFloat) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DFloat) String() string

+ type DGeography struct

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

+ func MustBeDGeography(e Expr) *DGeography

+ func NewDGeography(g geo.Geography) *DGeography

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

+ func (*DGeography) AmbiguousFormat() bool

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

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

+ func (d *DGeography) CompareError(ctx CompareContext, other Datum) (int, error)

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

+ func (d *DGeography) IsMax(ctx CompareContext) bool

+ func (d *DGeography) IsMin(ctx CompareContext) bool

+ func (d *DGeography) Max(ctx CompareContext) (Datum, bool)

+ func (d *DGeography) Min(ctx CompareContext) (Datum, bool)

+ func (d *DGeography) Next(ctx CompareContext) (Datum, bool)

+ func (d *DGeography) Prev(ctx CompareContext) (Datum, bool)

+ func (d *DGeography) Size() uintptr

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

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

+ func (node *DGeography) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DGeography) String() string

+ type DGeometry struct

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

+ func MustBeDGeometry(e Expr) *DGeometry

+ func NewDGeometry(g geo.Geometry) *DGeometry

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

+ func (*DGeometry) AmbiguousFormat() bool

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

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

+ func (d *DGeometry) CompareError(ctx CompareContext, other Datum) (int, error)

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

+ func (d *DGeometry) IsMax(ctx CompareContext) bool

+ func (d *DGeometry) IsMin(ctx CompareContext) bool

+ func (d *DGeometry) Max(ctx CompareContext) (Datum, bool)

+ func (d *DGeometry) Min(ctx CompareContext) (Datum, bool)

+ func (d *DGeometry) Next(ctx CompareContext) (Datum, bool)

+ func (d *DGeometry) Prev(ctx CompareContext) (Datum, bool)

+ func (d *DGeometry) Size() uintptr

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

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

+ func (node *DGeometry) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DGeometry) String() string

+ type DIPAddr struct

+ func AsDIPAddr(e Expr) (DIPAddr, bool)

+ func MustBeDIPAddr(e Expr) DIPAddr

+ func NewDIPAddr(d DIPAddr) *DIPAddr

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

+ func (*DIPAddr) AmbiguousFormat() bool

+ func (*DIPAddr) Max(ctx CompareContext) (Datum, bool)

+ func (*DIPAddr) Min(ctx CompareContext) (Datum, bool)

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

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

+ func (d *DIPAddr) CompareError(ctx CompareContext, other Datum) (int, error)

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

+ func (d *DIPAddr) IsMax(ctx CompareContext) bool

+ func (d *DIPAddr) IsMin(ctx CompareContext) bool

+ func (d *DIPAddr) Next(ctx CompareContext) (Datum, bool)

+ func (d *DIPAddr) Prev(ctx CompareContext) (Datum, bool)

+ func (d *DIPAddr) Size() uintptr

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

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

+ func (node *DIPAddr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DIPAddr) String() string

+ type DInt int64

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

+ func MustBeDInt(e Expr) DInt

+ func NewDInt(d DInt) *DInt

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

+ func (*DInt) AmbiguousFormat() bool

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

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

+ func (d *DInt) CompareError(ctx CompareContext, other Datum) (int, error)

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

+ func (d *DInt) IsMax(ctx CompareContext) bool

+ func (d *DInt) IsMin(ctx CompareContext) bool

+ func (d *DInt) Max(ctx CompareContext) (Datum, bool)

+ func (d *DInt) Min(ctx CompareContext) (Datum, bool)

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

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

+ func (d *DInt) Size() uintptr

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

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

+ func (node *DInt) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DInt) String() string

+ type DInterval struct

+ func AsDInterval(e Expr) (*DInterval, bool)

+ func MustBeDInterval(e Expr) *DInterval

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

+ func ParseDInterval(style duration.IntervalStyle, s string) (*DInterval, error)

+ func ParseDIntervalWithTypeMetadata(style duration.IntervalStyle, s string, itm types.IntervalTypeMetadata) (*DInterval, error)

+ func (*DInterval) AmbiguousFormat() bool

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

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

+ func (d *DInterval) CompareError(ctx CompareContext, other Datum) (int, error)

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

+ func (d *DInterval) IsMax(ctx CompareContext) bool

+ func (d *DInterval) IsMin(ctx CompareContext) bool

+ func (d *DInterval) Max(ctx CompareContext) (Datum, bool)

+ func (d *DInterval) Min(ctx CompareContext) (Datum, bool)

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

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

+ func (d *DInterval) Size() uintptr

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

+ func (d *DInterval) ValueAsISO8601String() string

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

+ func (node *DInterval) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DInterval) String() string

+ type DJSON struct

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

+ func MustBeDJSON(e Expr) DJSON

+ func NewDJSON(j json.JSON) *DJSON

+ func (*DJSON) AmbiguousFormat() bool

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

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

+ func (d *DJSON) CompareError(ctx CompareContext, other Datum) (int, error)

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

+ func (d *DJSON) IsComposite() bool

+ func (d *DJSON) IsMax(ctx CompareContext) bool

+ func (d *DJSON) IsMin(ctx CompareContext) bool

+ func (d *DJSON) Max(ctx CompareContext) (Datum, bool)

+ func (d *DJSON) Min(ctx CompareContext) (Datum, bool)

+ func (d *DJSON) Next(ctx CompareContext) (Datum, bool)

+ func (d *DJSON) Prev(ctx CompareContext) (Datum, bool)

+ func (d *DJSON) Size() uintptr

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

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

+ func (node *DJSON) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DJSON) String() string

+ type DOid struct

+ Oid oid.Oid

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

+ func IntToOid(i DInt) (*DOid, error)

+ func MakeDOid(d oid.Oid, semanticType *types.T) DOid

+ func MustBeDOid(e Expr) *DOid

+ func NewDOid(d oid.Oid) *DOid

+ func NewDOidWithName(d oid.Oid, typ *types.T, name string) *DOid

+ func NewDOidWithType(d oid.Oid, semanticType *types.T) *DOid

+ func NewDOidWithTypeAndName(d oid.Oid, semanticType *types.T, name string) *DOid

+ func ParseDOidAsInt(s string) (*DOid, error)

+ func (*DOid) AmbiguousFormat() bool

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

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

+ func (d *DOid) CompareError(ctx CompareContext, other Datum) (int, error)

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

+ func (d *DOid) IsMax(ctx CompareContext) bool

+ func (d *DOid) IsMin(ctx CompareContext) bool

+ func (d *DOid) Max(ctx CompareContext) (Datum, bool)

+ func (d *DOid) Min(ctx CompareContext) (Datum, bool)

+ func (d *DOid) Name() string

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

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

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

+ func (d *DOid) Size() uintptr

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

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

+ func (node *DOid) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DOid) String() string

+ type DOidWrapper struct

+ Oid oid.Oid

+ Wrapped Datum

+ func (d *DOidWrapper) AmbiguousFormat() bool

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

+ func (d *DOidWrapper) CompareError(ctx CompareContext, other Datum) (int, error)

+ func (d *DOidWrapper) Format(ctx *FmtCtx)

+ func (d *DOidWrapper) IsMax(ctx CompareContext) bool

+ func (d *DOidWrapper) IsMin(ctx CompareContext) bool

+ func (d *DOidWrapper) Max(ctx CompareContext) (Datum, bool)

+ func (d *DOidWrapper) Min(ctx CompareContext) (Datum, bool)

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

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

+ func (d *DOidWrapper) ResolvedType() *types.T

+ func (d *DOidWrapper) Size() uintptr

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

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

+ func (node *DOidWrapper) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DOidWrapper) String() string

+ type DPGLSN struct

+ func AsDPGLSN(e Expr) (*DPGLSN, bool)

+ func MustBeDPGLSN(e Expr) *DPGLSN

+ func NewDPGLSN(l lsn.LSN) *DPGLSN

+ func ParseDPGLSN(str string) (*DPGLSN, error)

+ func (*DPGLSN) AmbiguousFormat() bool

+ func (*DPGLSN) ResolvedType() *types.T

+ func (d *DPGLSN) Compare(ctx CompareContext, other Datum) int

+ func (d *DPGLSN) CompareError(ctx CompareContext, other Datum) (int, error)

+ func (d *DPGLSN) Format(ctx *FmtCtx)

+ func (d *DPGLSN) IsMax(ctx CompareContext) bool

+ func (d *DPGLSN) IsMin(ctx CompareContext) bool

+ func (d *DPGLSN) Max(ctx CompareContext) (Datum, bool)

+ func (d *DPGLSN) Min(ctx CompareContext) (Datum, bool)

+ func (d *DPGLSN) Next(ctx CompareContext) (Datum, bool)

+ func (d *DPGLSN) Prev(ctx CompareContext) (Datum, bool)

+ func (d *DPGLSN) Size() uintptr

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

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

+ func (node *DPGLSN) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DPGLSN) String() string

+ type DString string

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

+ func MustBeDString(e Expr) DString

+ func MustBeDStringOrDNull(e Expr) DString

+ func NewDString(d string) *DString

+ func (*DString) AmbiguousFormat() bool

+ func (*DString) IsMax(ctx CompareContext) bool

+ func (*DString) ResolvedType() *types.T

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

+ func (d *DString) CompareError(ctx CompareContext, other Datum) (int, error)

+ func (d *DString) Format(ctx *FmtCtx)

+ func (d *DString) IsMin(ctx CompareContext) bool

+ func (d *DString) Max(ctx CompareContext) (Datum, bool)

+ func (d *DString) Min(ctx CompareContext) (Datum, bool)

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

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

+ func (d *DString) Size() uintptr

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

+ func (d *DString) UnsafeBytes() []byte

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

+ func (node *DString) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DString) String() string

+ type DTSQuery struct

+ func AsDTSQuery(e Expr) (*DTSQuery, bool)

+ func MustBeDTSQuery(e Expr) *DTSQuery

+ func NewDTSQuery(q tsearch.TSQuery) *DTSQuery

+ func (d *DTSQuery) AmbiguousFormat() bool

+ func (d *DTSQuery) Compare(ctx CompareContext, other Datum) int

+ func (d *DTSQuery) CompareError(ctx CompareContext, other Datum) (int, error)

+ func (d *DTSQuery) Format(ctx *FmtCtx)

+ func (d *DTSQuery) IsMax(ctx CompareContext) bool

+ func (d *DTSQuery) IsMin(_ CompareContext) bool

+ func (d *DTSQuery) Max(ctx CompareContext) (Datum, bool)

+ func (d *DTSQuery) Min(ctx CompareContext) (Datum, bool)

+ func (d *DTSQuery) Next(_ CompareContext) (Datum, bool)

+ func (d *DTSQuery) Prev(_ CompareContext) (Datum, bool)

+ func (d *DTSQuery) ResolvedType() *types.T

+ func (d *DTSQuery) Size() uintptr

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

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

+ func (node *DTSQuery) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ type DTSVector struct

+ func AsDTSVector(e Expr) (*DTSVector, bool)

+ func MustBeDTSVector(e Expr) *DTSVector

+ func NewDTSVector(v tsearch.TSVector) *DTSVector

+ func (d *DTSVector) AmbiguousFormat() bool

+ func (d *DTSVector) Compare(ctx CompareContext, other Datum) int

+ func (d *DTSVector) CompareError(ctx CompareContext, other Datum) (int, error)

+ func (d *DTSVector) Format(ctx *FmtCtx)

+ func (d *DTSVector) IsMax(_ CompareContext) bool

+ func (d *DTSVector) IsMin(_ CompareContext) bool

+ func (d *DTSVector) Max(_ CompareContext) (Datum, bool)

+ func (d *DTSVector) Min(_ CompareContext) (Datum, bool)

+ func (d *DTSVector) Next(_ CompareContext) (Datum, bool)

+ func (d *DTSVector) Prev(_ CompareContext) (Datum, bool)

+ func (d *DTSVector) ResolvedType() *types.T

+ func (d *DTSVector) Size() uintptr

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

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

+ func (node *DTSVector) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ type DTime timeofday.TimeOfDay

+ func AsDTime(e Expr) (DTime, bool)

+ func MakeDTime(t timeofday.TimeOfDay) *DTime

+ func ParseDTime(ctx ParseContext, s string, precision time.Duration) (_ *DTime, dependsOnContext bool, _ error)

+ func (*DTime) AmbiguousFormat() bool

+ func (*DTime) ResolvedType() *types.T

+ func (d *DTime) Compare(ctx CompareContext, other Datum) int

+ func (d *DTime) CompareError(ctx CompareContext, other Datum) (int, error)

+ func (d *DTime) Format(ctx *FmtCtx)

+ func (d *DTime) IsMax(ctx CompareContext) bool

+ func (d *DTime) IsMin(ctx CompareContext) bool

+ func (d *DTime) Max(ctx CompareContext) (Datum, bool)

+ func (d *DTime) Min(ctx CompareContext) (Datum, bool)

+ func (d *DTime) Next(ctx CompareContext) (Datum, bool)

+ func (d *DTime) Prev(ctx CompareContext) (Datum, bool)

+ func (d *DTime) Round(precision time.Duration) *DTime

+ func (d *DTime) Size() uintptr

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

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

+ func (node *DTime) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DTime) String() string

+ type DTimeTZ struct

+ func AsDTimeTZ(e Expr) (DTimeTZ, bool)

+ func NewDTimeTZ(t timetz.TimeTZ) *DTimeTZ

+ func NewDTimeTZFromLocation(t timeofday.TimeOfDay, loc *time.Location) *DTimeTZ

+ func NewDTimeTZFromOffset(t timeofday.TimeOfDay, offsetSecs int32) *DTimeTZ

+ func NewDTimeTZFromTime(t time.Time) *DTimeTZ

+ func ParseDTimeTZ(ctx ParseContext, s string, precision time.Duration) (_ *DTimeTZ, dependsOnContext bool, _ error)

+ func (*DTimeTZ) AmbiguousFormat() bool

+ func (*DTimeTZ) ResolvedType() *types.T

+ func (d *DTimeTZ) Compare(ctx CompareContext, other Datum) int

+ func (d *DTimeTZ) CompareError(ctx CompareContext, other Datum) (int, error)

+ func (d *DTimeTZ) Format(ctx *FmtCtx)

+ func (d *DTimeTZ) IsMax(ctx CompareContext) bool

+ func (d *DTimeTZ) IsMin(ctx CompareContext) bool

+ func (d *DTimeTZ) Max(ctx CompareContext) (Datum, bool)

+ func (d *DTimeTZ) Min(ctx CompareContext) (Datum, bool)

+ func (d *DTimeTZ) Next(ctx CompareContext) (Datum, bool)

+ func (d *DTimeTZ) Prev(ctx CompareContext) (Datum, bool)

+ func (d *DTimeTZ) Round(precision time.Duration) *DTimeTZ

+ func (d *DTimeTZ) Size() uintptr

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

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

+ func (node *DTimeTZ) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DTimeTZ) String() string

+ type DTimestamp struct

+ func AsDTimestamp(e Expr) (DTimestamp, bool)

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

+ func MustBeDTimestamp(e Expr) DTimestamp

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

+ func ParseDTimestamp(ctx ParseContext, s string, precision time.Duration) (_ *DTimestamp, dependsOnContext bool, _ error)

+ func (*DTimestamp) AmbiguousFormat() bool

+ func (*DTimestamp) ResolvedType() *types.T

+ func (d *DTimestamp) AddTimeZone(loc *time.Location, precision time.Duration) (*DTimestampTZ, error)

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

+ func (d *DTimestamp) CompareError(ctx CompareContext, other Datum) (int, error)

+ func (d *DTimestamp) Format(ctx *FmtCtx)

+ func (d *DTimestamp) IsMax(ctx CompareContext) bool

+ func (d *DTimestamp) IsMin(ctx CompareContext) bool

+ func (d *DTimestamp) Max(ctx CompareContext) (Datum, bool)

+ func (d *DTimestamp) Min(ctx CompareContext) (Datum, bool)

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

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

+ func (d *DTimestamp) Round(precision time.Duration) (*DTimestamp, error)

+ func (d *DTimestamp) Size() uintptr

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

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

+ func (node *DTimestamp) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DTimestamp) String() string

+ type DTimestampTZ struct

+ func AsDTimestampTZ(e Expr) (DTimestampTZ, bool)

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

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

+ func MustBeDTimestampTZ(e Expr) DTimestampTZ

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

+ func ParseDTimestampTZ(ctx ParseContext, s string, precision time.Duration) (_ *DTimestampTZ, dependsOnContext bool, _ error)

+ func (*DTimestampTZ) AmbiguousFormat() bool

+ func (*DTimestampTZ) ResolvedType() *types.T

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

+ func (d *DTimestampTZ) CompareError(ctx CompareContext, other Datum) (int, error)

+ func (d *DTimestampTZ) EvalAtAndRemoveTimeZone(loc *time.Location, precision time.Duration) (*DTimestamp, error)

+ func (d *DTimestampTZ) Format(ctx *FmtCtx)

+ func (d *DTimestampTZ) IsMax(ctx CompareContext) bool

+ func (d *DTimestampTZ) IsMin(ctx CompareContext) bool

+ func (d *DTimestampTZ) Max(ctx CompareContext) (Datum, bool)

+ func (d *DTimestampTZ) Min(ctx CompareContext) (Datum, bool)

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

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

+ func (d *DTimestampTZ) Round(precision time.Duration) (*DTimestampTZ, error)

+ func (d *DTimestampTZ) Size() uintptr

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

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

+ func (node *DTimestampTZ) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DTimestampTZ) String() string

+ type DTuple struct

+ D Datums

+ func AsDTuple(e Expr) (*DTuple, bool)

+ func MakeDTuple(typ *types.T, d ...Datum) DTuple

+ func MustBeDTuple(e Expr) *DTuple

+ func NewDTuple(typ *types.T, d ...Datum) *DTuple

+ func NewDTupleWithLen(typ *types.T, l int) *DTuple

+ func ParseDTupleFromString(ctx ParseContext, s string, t *types.T) (_ *DTuple, dependsOnContext bool, _ error)

+ func (*DTuple) AmbiguousFormat() bool

+ func (d *DTuple) AssertSorted()

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

+ func (d *DTuple) CompareError(ctx CompareContext, other Datum) (int, error)

+ func (d *DTuple) ContainsNull() bool

+ func (d *DTuple) Format(ctx *FmtCtx)

+ func (d *DTuple) IsMax(ctx CompareContext) bool

+ func (d *DTuple) IsMin(ctx CompareContext) bool

+ func (d *DTuple) Max(ctx CompareContext) (Datum, bool)

+ func (d *DTuple) Min(ctx CompareContext) (Datum, bool)

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

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

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

+ func (d *DTuple) ResolvedType() *types.T

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

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

+ func (d *DTuple) Size() uintptr

+ func (d *DTuple) Sorted() bool

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

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

+ func (node *DTuple) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DTuple) String() string

+ type DUuid struct

+ func AsDUuid(e Expr) (DUuid, bool)

+ func MustBeDUuid(e Expr) DUuid

+ func NewDUuid(d DUuid) *DUuid

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

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

+ func (*DUuid) AmbiguousFormat() bool

+ func (*DUuid) Max(ctx CompareContext) (Datum, bool)

+ func (*DUuid) Min(ctx CompareContext) (Datum, bool)

+ func (*DUuid) ResolvedType() *types.T

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

+ func (d *DUuid) CompareError(ctx CompareContext, other Datum) (int, error)

+ func (d *DUuid) Format(ctx *FmtCtx)

+ func (d *DUuid) IsMax(ctx CompareContext) bool

+ func (d *DUuid) IsMin(ctx CompareContext) bool

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

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

+ func (d *DUuid) Size() uintptr

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

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

+ func (node *DUuid) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DUuid) String() string

+ type DVoid struct

+ func (*DVoid) AmbiguousFormat() bool

+ func (*DVoid) ResolvedType() *types.T

+ func (d *DVoid) Compare(ctx CompareContext, other Datum) int

+ func (d *DVoid) CompareError(ctx CompareContext, other Datum) (int, error)

+ func (d *DVoid) Format(ctx *FmtCtx)

+ func (d *DVoid) IsMax(ctx CompareContext) bool

+ func (d *DVoid) IsMin(ctx CompareContext) bool

+ func (d *DVoid) Max(ctx CompareContext) (Datum, bool)

+ func (d *DVoid) Min(ctx CompareContext) (Datum, bool)

+ func (d *DVoid) Next(ctx CompareContext) (Datum, bool)

+ func (d *DVoid) Prev(ctx CompareContext) (Datum, bool)

+ func (d *DVoid) Size() uintptr

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

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

+ func (node *DVoid) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *DVoid) String() string

+ type DataPlacement uint32

+ const DataPlacementDefault

+ const DataPlacementRestricted

+ const DataPlacementUnspecified

+ func (node *DataPlacement) Format(ctx *FmtCtx)

+ func (node *DataPlacement) TelemetryName() string

+ type Datum interface

+ AmbiguousFormat func() bool

+ Compare func(ctx CompareContext, other Datum) int

+ CompareError func(ctx CompareContext, other Datum) (int, error)

+ IsMax func(ctx CompareContext) bool

+ IsMin func(ctx CompareContext) bool

+ Max func(ctx CompareContext) (Datum, bool)

+ Min func(ctx CompareContext) (Datum, bool)

+ Next func(ctx CompareContext) (Datum, bool)

+ Prev func(ctx CompareContext) (Datum, bool)

+ Size func() uintptr

+ func AdjustValueToType(typ *types.T, inVal Datum) (outVal Datum, err error)

+ func AppendToMaybeNullArray(typ *types.T, left Datum, right Datum) (Datum, error)

+ func ConcatArrays(typ *types.T, left Datum, right Datum) (Datum, error)

+ func DatumNext(datum Datum, cmpCtx CompareContext, collationEnv *CollationEnvironment) (Datum, bool)

+ func DatumPrev(datum Datum, cmpCtx CompareContext, collationEnv *CollationEnvironment) (Datum, bool)

+ func MakeAllDEnumsInType(typ *types.T) []Datum

+ func MakeDJSON(d interface{}) (Datum, error)

+ func NewDIntVectorFromDArray(d *DArray) Datum

+ func NewDName(d string) Datum

+ func NewDNameFromDString(d *DString) Datum

+ func NewDOidVectorFromDArray(d *DArray) Datum

+ func NewDRefCursor(d string) Datum

+ func NewDRefCursorFromDString(d *DString) Datum

+ func NewDefaultDatum(collationEnv *CollationEnvironment, t *types.T) (d Datum, err error)

+ func ParseAndRequireString(t *types.T, s string, ctx ParseContext) (d Datum, dependsOnContext bool, err error)

+ func ParseDJSON(s string) (Datum, error)

+ func ParseDTSQuery(s string) (Datum, error)

+ func ParseDTSVector(s string) (Datum, error)

+ func PrependToMaybeNullArray(typ *types.T, left Datum, right Datum) (Datum, error)

+ func SampleDatum(t *types.T) Datum

+ func UnwrapDOidWrapper(d Datum) Datum

+ func WrapAsZeroOid(t *types.T) Datum

+ type DatumAlloc struct

+ AllocSize int

+ func (a *DatumAlloc) DoneInitNewDGeo(so *geopb.SpatialObject)

+ func (a *DatumAlloc) NewDBitArray(v DBitArray) *DBitArray

+ func (a *DatumAlloc) NewDBox2D(v DBox2D) *DBox2D

+ func (a *DatumAlloc) NewDBytes(v DBytes) *DBytes

+ func (a *DatumAlloc) NewDCollatedString(contents string, locale string) (*DCollatedString, error)

+ func (a *DatumAlloc) NewDDate(v DDate) *DDate

+ func (a *DatumAlloc) NewDDecimal(v DDecimal) *DDecimal

+ func (a *DatumAlloc) NewDEncodedKey(v DEncodedKey) *DEncodedKey

+ func (a *DatumAlloc) NewDEnum(v DEnum) *DEnum

+ func (a *DatumAlloc) NewDFloat(v DFloat) *DFloat

+ func (a *DatumAlloc) NewDGeography(v DGeography) *DGeography

+ func (a *DatumAlloc) NewDGeographyEmpty() *DGeography

+ func (a *DatumAlloc) NewDGeometry(v DGeometry) *DGeometry

+ func (a *DatumAlloc) NewDGeometryEmpty() *DGeometry

+ func (a *DatumAlloc) NewDIPAddr(v DIPAddr) *DIPAddr

+ func (a *DatumAlloc) NewDInt(v DInt) *DInt

+ func (a *DatumAlloc) NewDInterval(v DInterval) *DInterval

+ func (a *DatumAlloc) NewDJSON(v DJSON) *DJSON

+ func (a *DatumAlloc) NewDName(v DString) Datum

+ func (a *DatumAlloc) NewDOid(v DOid) Datum

+ func (a *DatumAlloc) NewDPGLSN(v DPGLSN) *DPGLSN

+ func (a *DatumAlloc) NewDRefCursor(v DString) Datum

+ func (a *DatumAlloc) NewDString(v DString) *DString

+ func (a *DatumAlloc) NewDTime(v DTime) *DTime

+ func (a *DatumAlloc) NewDTimeTZ(v DTimeTZ) *DTimeTZ

+ func (a *DatumAlloc) NewDTimestamp(v DTimestamp) *DTimestamp

+ func (a *DatumAlloc) NewDTimestampTZ(v DTimestampTZ) *DTimestampTZ

+ func (a *DatumAlloc) NewDTuple(v DTuple) *DTuple

+ func (a *DatumAlloc) NewDUuid(v DUuid) *DUuid

+ func (a *DatumAlloc) NewDVoid() *DVoid

+ func (a *DatumAlloc) NewDatums(num int) Datums

+ type Datums []Datum

+ func (d *Datums) Format(ctx *FmtCtx)

+ func (d Datums) Compare(evalCtx CompareContext, other Datums) int

+ func (d Datums) IsDistinctFrom(evalCtx CompareContext, other Datums) bool

+ func (d Datums) Len() int

+ func (node *Datums) String() string

+ type Deallocate struct

+ Name Name

+ func (*Deallocate) StatementReturnType() StatementReturnType

+ func (*Deallocate) StatementType() StatementType

+ func (n *Deallocate) StatementTag() string

+ func (n *Deallocate) String() string

+ func (node *Deallocate) Format(ctx *FmtCtx)

+ type DeclareCursor struct

+ Binary bool

+ Hold bool

+ Name Name

+ Scroll CursorScrollOption

+ Select *Select

+ Sensitivity CursorSensitivity

+ func (*DeclareCursor) StatementTag() string

+ func (*DeclareCursor) StatementType() StatementType

+ func (n *DeclareCursor) StatementReturnType() StatementReturnType

+ func (n *DeclareCursor) String() string

+ func (node *DeclareCursor) Format(ctx *FmtCtx)

+ type DefaultVal struct

+ func (DefaultVal) ResolvedType() *types.T

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

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

+ func (node *DefaultVal) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node DefaultVal) Format(ctx *FmtCtx)

+ func (node DefaultVal) String() string

+ type DeferrableMode int

+ const Deferrable

+ const NotDeferrable

+ const UnspecifiedDeferrableMode

+ func (d DeferrableMode) String() string

+ type Delete struct

+ Batch *Batch

+ Limit *Limit

+ OrderBy OrderBy

+ Returning ReturningClause

+ Table TableExpr

+ Using TableExprs

+ Where *Where

+ With *With

+ func (*Delete) StatementTag() string

+ func (*Delete) StatementType() StatementType

+ func (n *Delete) StatementReturnType() StatementReturnType

+ func (n *Delete) String() string

+ func (node *Delete) Format(ctx *FmtCtx)

+ type DescriptorCoverage int32

+ const AllDescriptors

+ const RequestedDescriptors

+ const SystemUsers

+ type DesiredObjectKind byte

+ const AnyObject

+ const TableObject

+ const TypeObject

+ type Direction int8

+ const Ascending

+ const DefaultDirection

+ const Descending

+ func (d Direction) String() string

+ type Discard struct

+ Mode DiscardMode

+ func (*Discard) StatementReturnType() StatementReturnType

+ func (*Discard) StatementType() StatementType

+ func (d *Discard) StatementTag() string

+ func (node *Discard) Format(ctx *FmtCtx)

+ func (node *Discard) String() string

+ type DiscardMode int

+ const DiscardModeAll

+ const DiscardModeSequences

+ const DiscardModeTemp

+ type DistinctOn []Expr

+ func (node *DistinctOn) Format(ctx *FmtCtx)

+ type DivDecimalIntOp struct

+ func (op *DivDecimalIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type DivDecimalOp struct

+ func (op *DivDecimalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type DivFloatOp struct

+ func (op *DivFloatOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type DivIntDecimalOp struct

+ func (op *DivIntDecimalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type DivIntOp struct

+ func (op *DivIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type DivIntervalFloatOp struct

+ func (op *DivIntervalFloatOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type DivIntervalIntOp struct

+ func (op *DivIntervalIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ 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) StatementReturnType() StatementReturnType

+ func (*DropDatabase) StatementTag() string

+ func (*DropDatabase) StatementType() StatementType

+ func (n *DropDatabase) String() string

+ func (node *DropDatabase) Format(ctx *FmtCtx)

+ type DropExternalConnection struct

+ ConnectionLabel Expr

+ func (*DropExternalConnection) StatementReturnType() StatementReturnType

+ func (*DropExternalConnection) StatementTag() string

+ func (*DropExternalConnection) StatementType() StatementType

+ func (n *DropExternalConnection) String() string

+ func (node *DropExternalConnection) Format(ctx *FmtCtx)

+ type DropIndex struct

+ Concurrently bool

+ DropBehavior DropBehavior

+ IfExists bool

+ IndexList TableIndexNames

+ func (*DropIndex) StatementReturnType() StatementReturnType

+ func (*DropIndex) StatementTag() string

+ func (*DropIndex) StatementType() StatementType

+ func (n *DropIndex) String() string

+ func (node *DropIndex) Format(ctx *FmtCtx)

+ type DropOwnedBy struct

+ DropBehavior DropBehavior

+ Roles RoleSpecList

+ func (*DropOwnedBy) StatementReturnType() StatementReturnType

+ func (*DropOwnedBy) StatementTag() string

+ func (*DropOwnedBy) StatementType() StatementType

+ func (n *DropOwnedBy) String() string

+ func (node *DropOwnedBy) Format(ctx *FmtCtx)

+ type DropRole struct

+ IfExists bool

+ IsRole bool

+ Names RoleSpecList

+ func (*DropRole) StatementReturnType() StatementReturnType

+ func (*DropRole) StatementTag() string

+ func (*DropRole) StatementType() StatementType

+ func (n *DropRole) String() string

+ func (node *DropRole) Format(ctx *FmtCtx)

+ type DropRoutine struct

+ DropBehavior DropBehavior

+ IfExists bool

+ Procedure bool

+ Routines RoutineObjs

+ func (*DropRoutine) StatementReturnType() StatementReturnType

+ func (*DropRoutine) StatementType() StatementType

+ func (n *DropRoutine) StatementTag() string

+ func (n *DropRoutine) String() string

+ func (node *DropRoutine) Format(ctx *FmtCtx)

+ type DropSchema struct

+ DropBehavior DropBehavior

+ IfExists bool

+ Names ObjectNamePrefixList

+ func (*DropSchema) StatementReturnType() StatementReturnType

+ func (*DropSchema) StatementTag() string

+ func (*DropSchema) StatementType() StatementType

+ func (n *DropSchema) String() string

+ func (node *DropSchema) Format(ctx *FmtCtx)

+ type DropSequence struct

+ DropBehavior DropBehavior

+ IfExists bool

+ Names TableNames

+ func (*DropSequence) StatementReturnType() StatementReturnType

+ func (*DropSequence) StatementTag() string

+ func (*DropSequence) StatementType() StatementType

+ func (n *DropSequence) String() string

+ func (node *DropSequence) Format(ctx *FmtCtx)

+ type DropTable struct

+ DropBehavior DropBehavior

+ IfExists bool

+ Names TableNames

+ func (*DropTable) StatementReturnType() StatementReturnType

+ func (*DropTable) StatementTag() string

+ func (*DropTable) StatementType() StatementType

+ func (n *DropTable) String() string

+ func (node *DropTable) Format(ctx *FmtCtx)

+ type DropTenant struct

+ IfExists bool

+ Immediate bool

+ TenantSpec *TenantSpec

+ func (*DropTenant) StatementReturnType() StatementReturnType

+ func (*DropTenant) StatementTag() string

+ func (*DropTenant) StatementType() StatementType

+ func (n *DropTenant) String() string

+ func (node *DropTenant) Format(ctx *FmtCtx)

+ type DropType struct

+ DropBehavior DropBehavior

+ IfExists bool

+ Names []*UnresolvedObjectName

+ func (*DropType) StatementReturnType() StatementReturnType

+ func (*DropType) StatementTag() string

+ func (*DropType) StatementType() StatementType

+ func (n *DropType) String() string

+ func (node *DropType) Format(ctx *FmtCtx)

+ type DropView struct

+ DropBehavior DropBehavior

+ IfExists bool

+ IsMaterialized bool

+ Names TableNames

+ func (*DropView) StatementReturnType() StatementReturnType

+ func (*DropView) StatementTag() string

+ func (*DropView) StatementType() StatementType

+ func (n *DropView) String() string

+ func (node *DropView) Format(ctx *FmtCtx)

+ type EnumValue string

+ func (n *EnumValue) Format(ctx *FmtCtx)

+ type EnumValueList []EnumValue

+ func (l *EnumValueList) Format(ctx *FmtCtx)

+ type Execute struct

+ DiscardRows bool

+ Name Name

+ Params Exprs

+ func (*Execute) StatementReturnType() StatementReturnType

+ func (*Execute) StatementTag() string

+ func (*Execute) StatementType() StatementType

+ func (n *Execute) String() string

+ func (node *Execute) Format(ctx *FmtCtx)

+ type Explain struct

+ Statement Statement

+ func (*Explain) StatementReturnType() StatementReturnType

+ func (*Explain) StatementTag() string

+ func (*Explain) StatementType() StatementType

+ func (n *Explain) String() string

+ func (node *Explain) Format(ctx *FmtCtx)

+ type ExplainAnalyze struct

+ Statement Statement

+ func (*ExplainAnalyze) StatementReturnType() StatementReturnType

+ func (*ExplainAnalyze) StatementTag() string

+ func (*ExplainAnalyze) StatementType() StatementType

+ func (n *ExplainAnalyze) String() string

+ func (node *ExplainAnalyze) Format(ctx *FmtCtx)

+ type ExplainFlag uint8

+ const ExplainFlagCatalog

+ const ExplainFlagEnv

+ const ExplainFlagJSON

+ const ExplainFlagMemo

+ const ExplainFlagRedact

+ const ExplainFlagShape

+ const ExplainFlagTypes

+ const ExplainFlagVerbose

+ const ExplainFlagViz

+ func (f ExplainFlag) String() string

+ type ExplainMode uint8

+ const ExplainDDL

+ const ExplainDebug

+ const ExplainDistSQL

+ const ExplainGist

+ const ExplainOpt

+ const ExplainPlan

+ const ExplainVec

+ func (m ExplainMode) String() string

+ type ExplainOptions struct

+ Flags [numExplainFlags + 1]bool

+ Mode ExplainMode

+ type Export struct

+ File Expr

+ FileFormat string

+ Options KVOptions

+ Query *Select

+ func (*Export) StatementReturnType() StatementReturnType

+ func (*Export) StatementTag() string

+ func (*Export) StatementType() StatementType

+ func (n *Export) String() string

+ func (node *Export) Format(ctx *FmtCtx)

+ type Expr interface

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

+ Walk func(Visitor) Expr

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

+ func StripMemoizedFuncs(expr Expr) Expr

+ func StripParens(expr Expr) Expr

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

+ type ExprContainer interface

+ Get func(i, j int) Expr

+ NumCols func() int

+ NumRows func() int

+ type ExprEvaluator interface

+ EvalAllColumnsSelector func(context.Context, *AllColumnsSelector) (Datum, error)

+ EvalAndExpr func(context.Context, *AndExpr) (Datum, error)

+ EvalArray func(context.Context, *Array) (Datum, error)

+ EvalArrayFlatten func(context.Context, *ArrayFlatten) (Datum, error)

+ EvalBinaryExpr func(context.Context, *BinaryExpr) (Datum, error)

+ EvalCaseExpr func(context.Context, *CaseExpr) (Datum, error)

+ EvalCastExpr func(context.Context, *CastExpr) (Datum, error)

+ EvalCoalesceExpr func(context.Context, *CoalesceExpr) (Datum, error)

+ EvalCollateExpr func(context.Context, *CollateExpr) (Datum, error)

+ EvalColumnAccessExpr func(context.Context, *ColumnAccessExpr) (Datum, error)

+ EvalColumnItem func(context.Context, *ColumnItem) (Datum, error)

+ EvalComparisonExpr func(context.Context, *ComparisonExpr) (Datum, error)

+ EvalDefaultVal func(context.Context, *DefaultVal) (Datum, error)

+ EvalFuncExpr func(context.Context, *FuncExpr) (Datum, error)

+ EvalIfErrExpr func(context.Context, *IfErrExpr) (Datum, error)

+ EvalIfExpr func(context.Context, *IfExpr) (Datum, error)

+ EvalIndexedVar func(context.Context, *IndexedVar) (Datum, error)

+ EvalIndirectionExpr func(context.Context, *IndirectionExpr) (Datum, error)

+ EvalIsNotNullExpr func(context.Context, *IsNotNullExpr) (Datum, error)

+ EvalIsNullExpr func(context.Context, *IsNullExpr) (Datum, error)

+ EvalIsOfTypeExpr func(context.Context, *IsOfTypeExpr) (Datum, error)

+ EvalNotExpr func(context.Context, *NotExpr) (Datum, error)

+ EvalNullIfExpr func(context.Context, *NullIfExpr) (Datum, error)

+ EvalOrExpr func(context.Context, *OrExpr) (Datum, error)

+ EvalParenExpr func(context.Context, *ParenExpr) (Datum, error)

+ EvalPlaceholder func(context.Context, *Placeholder) (Datum, error)

+ EvalRangeCond func(context.Context, *RangeCond) (Datum, error)

+ EvalRoutineExpr func(context.Context, *RoutineExpr) (Datum, error)

+ EvalSubquery func(context.Context, *Subquery) (Datum, error)

+ EvalTuple func(context.Context, *Tuple) (Datum, error)

+ EvalTupleStar func(context.Context, *TupleStar) (Datum, error)

+ EvalTypedDummy func(context.Context, *TypedDummy) (Datum, error)

+ EvalUnaryExpr func(context.Context, *UnaryExpr) (Datum, error)

+ EvalUnqualifiedStar func(context.Context, UnqualifiedStar) (Datum, error)

+ EvalUnresolvedName func(context.Context, *UnresolvedName) (Datum, error)

+ type Exprs []Expr

+ func (node *Exprs) Format(ctx *FmtCtx)

+ func (node *Exprs) String() string

+ type FamilyID = catid.FamilyID

+ type FamilyTableDef struct

+ Columns NameList

+ Name Name

+ func (node *FamilyTableDef) Format(ctx *FmtCtx)

+ type FetchCursor struct

+ func (*FetchCursor) StatementTag() string

+ func (*FetchCursor) StatementType() StatementType

+ func (f FetchCursor) Format(ctx *FmtCtx)

+ func (n *FetchCursor) StatementReturnType() StatementReturnType

+ func (n *FetchCursor) String() string

+ type FetchType int

+ const FetchAbsolute

+ const FetchAll

+ const FetchBackwardAll

+ const FetchFirst

+ const FetchLast

+ const FetchNormal

+ const FetchRelative

+ func (o FetchType) HasCount() bool

+ func (o FetchType) String() string

+ type FloorDivDecimalIntOp struct

+ func (op *FloorDivDecimalIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type FloorDivDecimalOp struct

+ func (op *FloorDivDecimalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type FloorDivFloatOp struct

+ func (op *FloorDivFloatOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type FloorDivIntDecimalOp struct

+ func (op *FloorDivIntDecimalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type FloorDivIntOp struct

+ func (op *FloorDivIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type FmtCtx struct

+ func NewFmtCtx(f FmtFlags, opts ...FmtCtxOption) *FmtCtx

+ func (ctx *FmtCtx) Close()

+ func (ctx *FmtCtx) CloseAndGetString() string

+ func (ctx *FmtCtx) FormatName(s string)

+ func (ctx *FmtCtx) FormatNameP(s *string)

+ func (ctx *FmtCtx) FormatNode(n NodeFormatter)

+ func (ctx *FmtCtx) FormatNodeSummary(n NodeFormatter)

+ func (ctx *FmtCtx) FormatTypeReference(ref ResolvableTypeReference)

+ func (ctx *FmtCtx) HasFlags(f FmtFlags) bool

+ func (ctx *FmtCtx) Printf(f string, args ...interface{})

+ func (ctx *FmtCtx) SetDataConversionConfig(dcc sessiondatapb.DataConversionConfig) sessiondatapb.DataConversionConfig

+ func (ctx *FmtCtx) SetLocation(loc *time.Location) *time.Location

+ func (ctx *FmtCtx) WithFlags(flags FmtFlags, fn func())

+ func (ctx *FmtCtx) WithReformatTableNames(tableNameFmt func(*FmtCtx, *TableName), fn func())

+ type FmtCtxOption func(*FmtCtx)

+ func FmtAnnotations(ann *Annotations) FmtCtxOption

+ func FmtDataConversionConfig(dcc sessiondatapb.DataConversionConfig) FmtCtxOption

+ func FmtIndexedTypeFormat(fn func(*FmtCtx, *OIDTypeReference)) FmtCtxOption

+ func FmtIndexedVarFormat(fn func(ctx *FmtCtx, idx int)) FmtCtxOption

+ func FmtLocation(loc *time.Location) FmtCtxOption

+ func FmtPlaceholderFormat(placeholderFn func(_ *FmtCtx, _ *Placeholder)) FmtCtxOption

+ func FmtReformatTableNames(tableNameFmt func(*FmtCtx, *TableName)) FmtCtxOption

+ type FmtFlags int

+ func (f FmtFlags) EncodeFlags() lexbase.EncodeFlags

+ func (f FmtFlags) HasAnyFlags(subset FmtFlags) bool

+ func (f FmtFlags) HasFlags(subset FmtFlags) bool

+ type FnOverload interface

+ type FnWithExprsOverload interface

+ FnWithExprs func()

+ type ForeignKeyConstraintTableDef struct

+ Actions ReferenceActions

+ FromCols NameList

+ IfNotExists bool

+ Match CompositeKeyMatchMethod

+ Name Name

+ Table TableName

+ ToCols NameList

+ func (node *ForeignKeyConstraintTableDef) Format(ctx *FmtCtx)

+ func (node *ForeignKeyConstraintTableDef) SetIfNotExists()

+ func (node *ForeignKeyConstraintTableDef) SetName(name Name)

+ type From struct

+ AsOf AsOfClause

+ Tables TableExprs

+ func (node *From) Format(ctx *FmtCtx)

+ type FullBackupClause struct

+ AlwaysFull bool

+ Recurrence Expr

+ type FuncExpr struct

+ AggType AggType

+ Exprs Exprs

+ Filter Expr

+ Func ResolvableFunctionReference

+ InCall bool

+ OrderBy OrderBy

+ Type funcType

+ WindowDef *WindowDef

+ func NewTypedFuncExpr(ref ResolvableFunctionReference, aggQualifier funcType, exprs TypedExprs, ...) *FuncExpr

+ func (expr *FuncExpr) MaybeWrapError(err error) error

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

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

+ func (node *FuncExpr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *FuncExpr) Format(ctx *FmtCtx)

+ func (node *FuncExpr) IsDistSQLBlocklist() bool

+ func (node *FuncExpr) IsGeneratorClass() bool

+ func (node *FuncExpr) IsVectorizeStreaming() bool

+ func (node *FuncExpr) IsWindowFunctionApplication() bool

+ func (node *FuncExpr) ResolvedOverload() *Overload

+ func (node *FuncExpr) SetTypeAnnotation(t *types.T)

+ func (node *FuncExpr) String() string

+ func (ta FuncExpr) ResolvedType() *types.T

+ type FunctionClass int

+ const AggregateClass

+ const GeneratorClass

+ const NormalClass

+ const SQLClass

+ const WindowClass

+ func (c FunctionClass) String() string

+ type FunctionDefinition struct

+ Definition []*Overload

+ Name string

+ func NewFunctionDefinition(name string, props *FunctionProperties, def []Overload) *FunctionDefinition

+ func (fd *FunctionDefinition) Format(ctx *FmtCtx)

+ func (fd *FunctionDefinition) String() string

+ type FunctionOID struct

+ OID oid.Oid

+ func (o *FunctionOID) Format(ctx *FmtCtx)

+ func (o *FunctionOID) String() string

+ type FunctionProperties struct

+ AmbiguousReturnType bool

+ AvailableOnPublicSchema bool

+ Category string

+ CompositeInsensitive bool

+ DistsqlBlocklist bool

+ HasSequenceArguments bool

+ Private bool

+ ReturnLabels []string

+ ReturnsRecordType bool

+ Undocumented bool

+ UnsupportedWithIssue int

+ VectorizeStreaming bool

+ func (fp *FunctionProperties) ShouldDocument() bool

+ type FunctionReference interface

+ type FunctionReferenceResolver interface

+ ResolveFunction func(ctx context.Context, name UnresolvedRoutineName, path SearchPath) (*ResolvedFunctionDefinition, error)

+ ResolveFunctionByOID func(ctx context.Context, oid oid.Oid) (*RoutineName, *Overload, error)

+ type GeneratedAlwaysAsIdentity struct

+ SeqOptions SequenceOptions

+ type GeneratedByDefAsIdentity struct

+ SeqOptions SequenceOptions

+ type GeneratedIdentityType int

+ const GeneratedAlways

+ const GeneratedByDefault

+ type GeneratorOverload interface

+ Generator func()

+ type GeneratorWithExprsOverload interface

+ GeneratorWithExprs func()

+ type Grant struct

+ Grantees RoleSpecList

+ Privileges privilege.List

+ Targets GrantTargetList

+ WithGrantOption bool

+ func (*Grant) StatementReturnType() StatementReturnType

+ func (*Grant) StatementTag() string

+ func (*Grant) StatementType() StatementType

+ func (n *Grant) String() string

+ func (node *Grant) Format(ctx *FmtCtx)

+ type GrantRole struct

+ AdminOption bool

+ Members RoleSpecList

+ Roles NameList

+ func (*GrantRole) StatementReturnType() StatementReturnType

+ func (*GrantRole) StatementTag() string

+ func (*GrantRole) StatementType() StatementType

+ func (n *GrantRole) String() string

+ func (node *GrantRole) Format(ctx *FmtCtx)

+ type GrantTargetList struct

+ AllFunctionsInSchema bool

+ AllProceduresInSchema bool

+ AllSequencesInSchema bool

+ AllTablesInSchema bool

+ Databases NameList

+ ExternalConnections NameList

+ ForRoles bool

+ Functions RoutineObjs

+ Procedures RoutineObjs

+ Roles RoleSpecList

+ Schemas ObjectNamePrefixList

+ System bool

+ Tables TableAttrs

+ Types []*UnresolvedObjectName

+ func (tl *GrantTargetList) Format(ctx *FmtCtx)

+ type GroupBy []Expr

+ func (node *GroupBy) Format(ctx *FmtCtx)

+ type HiddenConstraint struct

+ type HiddenFromShowQueries interface

+ type HomogeneousType struct

+ func (HomogeneousType) GetAt(i int) *types.T

+ func (HomogeneousType) Length() int

+ func (HomogeneousType) Match(types []*types.T) bool

+ func (HomogeneousType) MatchAt(typ *types.T, i int) bool

+ func (HomogeneousType) MatchAtIdentical(typ *types.T, i int) bool

+ func (HomogeneousType) MatchIdentical(types []*types.T) bool

+ func (HomogeneousType) MatchLen(l int) bool

+ func (HomogeneousType) String() string

+ func (HomogeneousType) Types() []*types.T

+ type ID = catid.ColumnID

+ type IfErrExpr struct

+ Cond Expr

+ Else Expr

+ ErrCode Expr

+ func NewTypedIfErrExpr(cond, orElse, errCode TypedExpr) *IfErrExpr

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

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

+ func (node *IfErrExpr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *IfErrExpr) Format(ctx *FmtCtx)

+ func (node *IfErrExpr) String() string

+ func (ta IfErrExpr) ResolvedType() *types.T

+ type IfExpr struct

+ Cond Expr

+ Else Expr

+ True Expr

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

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

+ func (node *IfExpr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *IfExpr) Format(ctx *FmtCtx)

+ func (node *IfExpr) String() string

+ func (node *IfExpr) TypedCondExpr() TypedExpr

+ func (node *IfExpr) TypedElseExpr() TypedExpr

+ func (node *IfExpr) TypedTrueExpr() TypedExpr

+ func (ta IfExpr) ResolvedType() *types.T

+ type Import struct

+ Bundle bool

+ FileFormat string

+ Files Exprs

+ Into bool

+ IntoCols NameList

+ Options KVOptions

+ Table *TableName

+ func (*Import) StatementReturnType() StatementReturnType

+ func (*Import) StatementTag() string

+ func (*Import) StatementType() StatementType

+ func (n *Import) String() string

+ func (node *Import) Format(ctx *FmtCtx)

+ type InTupleOp struct

+ func (op *InTupleOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type IndexElem struct

+ Column Name

+ Direction Direction

+ Expr Expr

+ NullsOrder NullsOrder

+ OpClass Name

+ func (node *IndexElem) Format(ctx *FmtCtx)

+ type IndexElemList []IndexElem

+ func (l *IndexElemList) Format(ctx *FmtCtx)

+ type IndexFlags struct

+ Direction Direction

+ FamilyID *FamilyID

+ ForceZigzag bool

+ IgnoreForeignKeys bool

+ IgnoreUniqueWithoutIndexKeys bool

+ Index UnrestrictedName

+ IndexID IndexID

+ NoFullScan bool

+ NoIndexJoin bool

+ NoZigzagJoin bool

+ ZigzagIndexIDs []IndexID

+ ZigzagIndexes []UnrestrictedName

+ func (ih *IndexFlags) Check() error

+ func (ih *IndexFlags) CombineWith(other *IndexFlags) error

+ func (ih *IndexFlags) ForceIndex() bool

+ func (ih *IndexFlags) Format(ctx *FmtCtx)

+ type IndexID = catid.IndexID

+ type IndexInvisibility struct

+ FloatProvided bool

+ Value float64

+ type IndexLookupFlags struct

+ IncludeNonActiveIndex bool

+ IncludeOfflineTable bool

+ Required bool

+ type IndexTableDef struct

+ Columns IndexElemList

+ Inverted bool

+ Invisibility IndexInvisibility

+ Name Name

+ PartitionByIndex *PartitionByIndex

+ Predicate Expr

+ Sharded *ShardedIndexDef

+ StorageParams StorageParams

+ Storing NameList

+ func (node *IndexTableDef) Format(ctx *FmtCtx)

+ type IndexedVar struct

+ Idx int

+ Used bool

+ func NewOrdinalReference(r int) *IndexedVar

+ func NewTypedOrdinalReference(r int, typ *types.T) *IndexedVar

+ func (*IndexedVar) Variable()

+ func (node *IndexedVar) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *IndexedVar) String() string

+ func (v *IndexedVar) Format(ctx *FmtCtx)

+ func (v *IndexedVar) ResolvedType() *types.T

+ func (v *IndexedVar) TypeCheck(_ context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error)

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

+ type IndexedVarContainer interface

+ IndexedVarNodeFormatter func(idx int) NodeFormatter

+ IndexedVarResolvedType func(idx int) *types.T

+ type IndexedVarHelper struct

+ func MakeIndexedVarHelper(container IndexedVarContainer, numVars int) IndexedVarHelper

+ func MakeTypesOnlyIndexedVarHelper(types []*types.T) IndexedVarHelper

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

+ func (h *IndexedVarHelper) AppendSlot() int

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

+ func (h *IndexedVarHelper) Container() IndexedVarContainer

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

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

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

+ func (h *IndexedVarHelper) IndexedVarWithType(idx int, typ *types.T) *IndexedVar

+ func (h *IndexedVarHelper) Rebind(expr TypedExpr) TypedExpr

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

+ type IndirectionExpr struct

+ Expr Expr

+ Indirection ArraySubscripts

+ func NewTypedIndirectionExpr(expr, index TypedExpr, typ *types.T) *IndirectionExpr

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

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

+ func (node *IndirectionExpr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *IndirectionExpr) Format(ctx *FmtCtx)

+ func (node *IndirectionExpr) String() string

+ func (ta IndirectionExpr) ResolvedType() *types.T

+ type Insert struct

+ Columns NameList

+ OnConflict *OnConflict

+ Returning ReturningClause

+ Rows *Select

+ Table TableExpr

+ With *With

+ func (*Insert) StatementTag() string

+ func (*Insert) StatementType() StatementType

+ func (n *Insert) StatementReturnType() StatementReturnType

+ func (n *Insert) String() string

+ func (node *Insert) DefaultValues() bool

+ func (node *Insert) Format(ctx *FmtCtx)

+ type IsNotNullExpr struct

+ Expr Expr

+ func NewTypedIsNotNullExpr(expr TypedExpr) *IsNotNullExpr

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

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

+ func (node *IsNotNullExpr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *IsNotNullExpr) Format(ctx *FmtCtx)

+ func (node *IsNotNullExpr) String() string

+ func (node *IsNotNullExpr) TypedInnerExpr() TypedExpr

+ func (ta IsNotNullExpr) ResolvedType() *types.T

+ type IsNullExpr struct

+ Expr Expr

+ func NewTypedIsNullExpr(expr TypedExpr) *IsNullExpr

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

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

+ func (node *IsNullExpr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *IsNullExpr) Format(ctx *FmtCtx)

+ func (node *IsNullExpr) String() string

+ func (node *IsNullExpr) TypedInnerExpr() TypedExpr

+ func (ta IsNullExpr) ResolvedType() *types.T

+ type IsOfTypeExpr struct

+ Expr Expr

+ Not bool

+ Types []ResolvableTypeReference

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

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

+ func (node *IsOfTypeExpr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *IsOfTypeExpr) Format(ctx *FmtCtx)

+ func (node *IsOfTypeExpr) ResolvedTypes() []*types.T

+ func (node *IsOfTypeExpr) String() string

+ func (ta IsOfTypeExpr) ResolvedType() *types.T

+ type IsolationLevel int

+ const ReadCommittedIsolation

+ const ReadUncommittedIsolation

+ const RepeatableReadIsolation

+ const SerializableIsolation

+ const SnapshotIsolation

+ const UnspecifiedIsolation

+ func IsolationLevelFromKVTxnIsolationLevel(level isolation.Level) IsolationLevel

+ func (i IsolationLevel) String() string

+ func (k IsolationLevel) SafeValue()

+ type JSONAllExistsOp struct

+ func (op *JSONAllExistsOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type JSONExistsOp struct

+ func (op *JSONExistsOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type JSONFetchTextIntOp struct

+ func (op *JSONFetchTextIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type JSONFetchTextPathOp struct

+ func (op *JSONFetchTextPathOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type JSONFetchTextStringOp struct

+ func (op *JSONFetchTextStringOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type JSONFetchValIntOp struct

+ func (op *JSONFetchValIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type JSONFetchValPathOp struct

+ func (op *JSONFetchValPathOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type JSONFetchValStringOp struct

+ func (op *JSONFetchValStringOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type JSONSomeExistsOp struct

+ func (op *JSONSomeExistsOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type JobCommand int

+ const CancelJob

+ const PauseJob

+ const ResumeJob

+ type JoinCond interface

+ type JoinTableExpr struct

+ Cond JoinCond

+ Hint string

+ JoinType string

+ Left TableExpr

+ Right TableExpr

+ func (expr *JoinTableExpr) WalkTableExpr(v Visitor) TableExpr

+ func (node *JoinTableExpr) Format(ctx *FmtCtx)

+ func (node *JoinTableExpr) String() string

+ type KVOption struct

+ Key Name

+ Value Expr

+ type KVOptions []KVOption

+ func (o *KVOptions) Format(ctx *FmtCtx)

+ func (o *KVOptions) HasKey(key Name) bool

+ type LShiftINetOp struct

+ func (op *LShiftINetOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type LShiftIntOp struct

+ func (op *LShiftIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type LShiftVarBitIntOp struct

+ func (op *LShiftVarBitIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type LabelSpec struct

+ IfNotExists bool

+ Label Expr

+ func (l *LabelSpec) Format(ctx *FmtCtx)

+ type LikeTableDef struct

+ Name TableName

+ Options []LikeTableOption

+ func (def *LikeTableDef) Format(ctx *FmtCtx)

+ type LikeTableOpt int

+ const LikeTableOptConstraints

+ const LikeTableOptDefaults

+ const LikeTableOptGenerated

+ const LikeTableOptIndexes

+ func (o LikeTableOpt) Has(other LikeTableOpt) bool

+ func (o LikeTableOpt) String() string

+ type LikeTableOption struct

+ Excluded bool

+ Opt LikeTableOpt

+ func (l LikeTableOption) Format(ctx *FmtCtx)

+ type LikeTenantSpec struct

+ OtherTenant *TenantSpec

+ func (node *LikeTenantSpec) Format(ctx *FmtCtx)

+ type Limit struct

+ Count Expr

+ LimitAll bool

+ Offset Expr

+ func (node *Limit) Format(ctx *FmtCtx)

+ type LineWidthMode int

+ type ListPartition struct

+ Exprs Exprs

+ Name Name

+ Subpartition *PartitionBy

+ func (node *ListPartition) Format(ctx *FmtCtx)

+ type LiteralValuesClause struct

+ Rows ExprContainer

+ func (*LiteralValuesClause) StatementReturnType() StatementReturnType

+ func (*LiteralValuesClause) StatementTag() string

+ func (*LiteralValuesClause) StatementType() StatementType

+ func (n *LiteralValuesClause) String() string

+ func (node *LiteralValuesClause) Format(ctx *FmtCtx)

+ type Locality struct

+ LocalityLevel LocalityLevel

+ RegionalByRowColumn Name

+ TableRegion Name

+ func (node *Locality) Format(ctx *FmtCtx)

+ type LocalityLevel int

+ const LocalityLevelGlobal

+ const LocalityLevelRow

+ const LocalityLevelTable

+ type LockingClause []*LockingItem

+ func (node *LockingClause) Format(ctx *FmtCtx)

+ type LockingDurability byte

+ const LockDurabilityBestEffort

+ const LockDurabilityGuaranteed

+ func (d LockingDurability) Max(d2 LockingDurability) LockingDurability

+ func (d LockingDurability) String() string

+ type LockingForm byte

+ const LockPredicate

+ const LockRecord

+ func (p LockingForm) Max(p2 LockingForm) LockingForm

+ func (p LockingForm) String() string

+ type LockingItem struct

+ Form LockingForm

+ Strength LockingStrength

+ Targets TableNames

+ WaitPolicy LockingWaitPolicy

+ func (f *LockingItem) Format(ctx *FmtCtx)

+ type LockingStrength byte

+ const ForKeyShare

+ const ForNoKeyUpdate

+ const ForNone

+ const ForShare

+ const ForUpdate

+ func (s LockingStrength) Format(ctx *FmtCtx)

+ func (s LockingStrength) Max(s2 LockingStrength) LockingStrength

+ func (s LockingStrength) String() string

+ type LockingWaitPolicy byte

+ const LockWaitBlock

+ const LockWaitError

+ const LockWaitSkipLocked

+ func (p LockingWaitPolicy) Format(ctx *FmtCtx)

+ func (p LockingWaitPolicy) Max(p2 LockingWaitPolicy) LockingWaitPolicy

+ func (p LockingWaitPolicy) String() string

+ type MatchLikeOp struct

+ CaseInsensitive bool

+ func (op *MatchLikeOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MatchRegexpOp struct

+ CaseInsensitive bool

+ Escape rune

+ func (op *MatchRegexpOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusDateIntOp struct

+ func (op *MinusDateIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusDateIntervalOp struct

+ func (op *MinusDateIntervalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusDateOp struct

+ func (op *MinusDateOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusDateTimeOp struct

+ func (op *MinusDateTimeOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusDecimalIntOp struct

+ func (op *MinusDecimalIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusDecimalOp struct

+ func (op *MinusDecimalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusFloatOp struct

+ func (op *MinusFloatOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusINetIntOp struct

+ func (op *MinusINetIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusINetOp struct

+ func (op *MinusINetOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusIntDecimalOp struct

+ func (op *MinusIntDecimalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusIntOp struct

+ func (op *MinusIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusIntervalOp struct

+ func (op *MinusIntervalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusJsonbIntOp struct

+ func (op *MinusJsonbIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusJsonbStringArrayOp struct

+ func (op *MinusJsonbStringArrayOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusJsonbStringOp struct

+ func (op *MinusJsonbStringOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusPGLSNDecimalOp struct

+ func (op *MinusPGLSNDecimalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusPGLSNOp struct

+ func (op *MinusPGLSNOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusTimeIntervalOp struct

+ func (op *MinusTimeIntervalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusTimeOp struct

+ func (op *MinusTimeOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusTimeTZIntervalOp struct

+ func (op *MinusTimeTZIntervalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusTimestampIntervalOp struct

+ func (op *MinusTimestampIntervalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusTimestampOp struct

+ func (op *MinusTimestampOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusTimestampTZIntervalOp struct

+ func (op *MinusTimestampTZIntervalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusTimestampTZOp struct

+ func (op *MinusTimestampTZOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusTimestampTZTimestampOp struct

+ func (op *MinusTimestampTZTimestampOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MinusTimestampTimestampTZOp struct

+ func (op *MinusTimestampTimestampTZOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type ModDecimalIntOp struct

+ func (op *ModDecimalIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type ModDecimalOp struct

+ func (op *ModDecimalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type ModFloatOp struct

+ func (op *ModFloatOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type ModIntDecimalOp struct

+ func (op *ModIntDecimalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type ModIntOp struct

+ func (op *ModIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type ModStringOp struct

+ func (op *ModStringOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MoveCursor struct

+ func (*MoveCursor) StatementTag() string

+ func (*MoveCursor) StatementType() StatementType

+ func (m MoveCursor) Format(ctx *FmtCtx)

+ func (n *MoveCursor) StatementReturnType() StatementReturnType

+ func (n *MoveCursor) String() string

+ type MultDecimalIntOp struct

+ func (op *MultDecimalIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MultDecimalIntervalOp struct

+ func (op *MultDecimalIntervalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MultDecimalOp struct

+ func (op *MultDecimalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MultFloatIntervalOp struct

+ func (op *MultFloatIntervalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MultFloatOp struct

+ func (op *MultFloatOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MultIntDecimalOp struct

+ func (op *MultIntDecimalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MultIntIntervalOp struct

+ func (op *MultIntIntervalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MultIntOp struct

+ func (op *MultIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MultIntervalDecimalOp struct

+ func (op *MultIntervalDecimalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MultIntervalFloatOp struct

+ func (op *MultIntervalFloatOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MultIntervalIntOp struct

+ func (op *MultIntervalIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type MultipleResultsError struct

+ SQL string

+ func (e *MultipleResultsError) Error() string

+ type Name string

+ func (n *Name) Format(ctx *FmtCtx)

+ func (n Name) Normalize() string

+ func (node *Name) String() string

+ type NameList []Name

+ func (l *NameList) Format(ctx *FmtCtx)

+ func (l NameList) Contains(name Name) bool

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

+ func (list *NameList) String() string

+ type NameParts = [4]string

+ type NamedColumnQualification struct

+ Name Name

+ Qualification ColumnQualification

+ type NaturalJoinCond struct

+ func (NaturalJoinCond) Format(ctx *FmtCtx)

+ type NewParseContextOption func(ret *simpleParseContext)

+ func NewParseContextOptionDateStyle(dateStyle pgdate.DateStyle) NewParseContextOption

+ type NoReturningClause struct

+ func (*NoReturningClause) Format(_ *FmtCtx)

+ type NodeFormatter interface

+ Format func(ctx *FmtCtx)

+ type NotExpr struct

+ Expr Expr

+ func NewTypedNotExpr(expr TypedExpr) *NotExpr

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

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

+ func (node *NotExpr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *NotExpr) Format(ctx *FmtCtx)

+ func (node *NotExpr) String() string

+ func (node *NotExpr) TypedInnerExpr() TypedExpr

+ func (ta NotExpr) ResolvedType() *types.T

+ type NotNullConstraint struct

+ type NullConstraint struct

+ type NullIfExpr struct

+ Expr1 Expr

+ Expr2 Expr

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

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

+ func (node *NullIfExpr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *NullIfExpr) Format(ctx *FmtCtx)

+ func (node *NullIfExpr) String() string

+ func (ta NullIfExpr) ResolvedType() *types.T

+ type Nullability int

+ const NotNull

+ const Null

+ const SilentNull

+ func RandomNullability(rand *rand.Rand, nullableOnly bool) Nullability

+ type NullsOrder int8

+ const DefaultNullsOrder

+ const NullsFirst

+ const NullsLast

+ func (n NullsOrder) String() string

+ type NumVal struct

+ func NewNumVal(value constant.Value, origString string, negative bool) *NumVal

+ func (expr *NumVal) AsConstantInt() (constant.Value, bool)

+ func (expr *NumVal) AsConstantValue() constant.Value

+ func (expr *NumVal) AsInt32() (int32, error)

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

+ func (expr *NumVal) AvailableTypes() []*types.T

+ func (expr *NumVal) DesirableTypes() []*types.T

+ func (expr *NumVal) ExactString() string

+ func (expr *NumVal) Format(ctx *FmtCtx)

+ func (expr *NumVal) Kind() constant.Kind

+ func (expr *NumVal) Negate()

+ func (expr *NumVal) OrigString() string

+ func (expr *NumVal) ResolveAsType(ctx context.Context, semaCtx *SemaContext, typ *types.T) (TypedExpr, error)

+ func (expr *NumVal) SetNegative()

+ func (expr *NumVal) ShouldBeInt64() bool

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

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

+ func (node *NumVal) String() string

+ type OIDTypeReference struct

+ OID oid.Oid

+ func (node *OIDTypeReference) SQLString() string

+ type ObjectLookupFlags struct

+ AllowWithoutPrimaryKey bool

+ AssertNotLeased bool

+ DesiredObjectKind DesiredObjectKind

+ DesiredTableDescKind RequiredTableKind

+ IncludeOffline bool

+ RequireMutable bool

+ Required bool

+ type ObjectName interface

+ Catalog func() string

+ FQString func() string

+ Object func() string

+ Schema func() string

+ type ObjectNamePrefix struct

+ CatalogName Name

+ ExplicitCatalog bool

+ ExplicitSchema bool

+ SchemaName Name

+ func (tp *ObjectNamePrefix) Catalog() string

+ func (tp *ObjectNamePrefix) Format(ctx *FmtCtx)

+ func (tp *ObjectNamePrefix) Schema() string

+ func (tp *ObjectNamePrefix) String() string

+ type ObjectNamePrefixList []ObjectNamePrefix

+ func (tp ObjectNamePrefixList) Format(ctx *FmtCtx)

+ type ObserverStatement interface

+ type OnConflict struct

+ ArbiterPredicate Expr

+ Columns NameList

+ Constraint Name

+ DoNothing bool

+ Exprs UpdateExprs

+ Where *Where

+ func (oc *OnConflict) IsUpsertAlias() bool

+ type OnJoinCond struct

+ Expr Expr

+ func (node *OnJoinCond) Format(ctx *FmtCtx)

+ type OpEvaluator interface

+ type Operator interface

+ Operator func()

+ type OrExpr struct

+ Left Expr

+ Right Expr

+ func NewTypedOrExpr(left, right TypedExpr) *OrExpr

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

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

+ func (node *OrExpr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *OrExpr) Format(ctx *FmtCtx)

+ func (node *OrExpr) String() string

+ func (node *OrExpr) TypedLeft() TypedExpr

+ func (node *OrExpr) TypedRight() TypedExpr

+ func (ta OrExpr) ResolvedType() *types.T

+ type Order struct

+ Direction Direction

+ Expr Expr

+ Index UnrestrictedName

+ NullsOrder NullsOrder

+ OrderType OrderType

+ Table TableName

+ func (node *Order) Equal(other *Order) bool

+ func (node *Order) Format(ctx *FmtCtx)

+ type OrderBy []*Order

+ func (node *OrderBy) Format(ctx *FmtCtx)

+ type OrderType int

+ const OrderByColumn

+ const OrderByIndex

+ type OverlapsArrayOp struct

+ func (op *OverlapsArrayOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type OverlapsINetOp struct

+ func (op *OverlapsINetOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type Overload struct

+ AggregateFunc AggregateOverload

+ Body string

+ CalledOnNullInput bool

+ Class FunctionClass

+ DistsqlBlocklist bool

+ Fn FnOverload

+ FnWithExprs FnWithExprsOverload

+ Generator GeneratorOverload

+ GeneratorWithExprs GeneratorWithExprsOverload

+ IgnoreVolatilityCheck bool

+ Info string

+ Language RoutineLanguage

+ Oid oid.Oid

+ OnTypeCheck *func()

+ PreferredOverload bool

+ ReturnSet bool

+ ReturnType ReturnTyper

+ SQLFn SQLFnOverload

+ SpecializedVecBuiltin SpecializedVectorizedBuiltin

+ Type RoutineType

+ Types TypeList

+ UDFContainsOnlySignature bool

+ Version uint64

+ Volatility volatility.V

+ WindowFunc WindowOverload

+ func (b Overload) FixedReturnType() *types.T

+ func (b Overload) HasSQLBody() bool

+ func (b Overload) InferReturnTypeFromInputArgTypes(inputTypes []*types.T) *types.T

+ func (b Overload) IsGenerator() bool

+ func (b Overload) Signature(simplify bool) string

+ type ParamType struct

+ Name string

+ Typ *types.T

+ type ParamTypes []ParamType

+ func (p ParamTypes) GetAt(i int) *types.T

+ func (p ParamTypes) Length() int

+ func (p ParamTypes) Match(types []*types.T) bool

+ func (p ParamTypes) MatchAt(typ *types.T, i int) bool

+ func (p ParamTypes) MatchAtIdentical(typ *types.T, i int) bool

+ func (p ParamTypes) MatchIdentical(types []*types.T) bool

+ func (p ParamTypes) MatchLen(l int) bool

+ func (p ParamTypes) SetAt(i int, name string, t *types.T)

+ func (p ParamTypes) String() string

+ func (p ParamTypes) Types() []*types.T

+ type ParenExpr struct

+ Expr Expr

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

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

+ func (node *ParenExpr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *ParenExpr) Format(ctx *FmtCtx)

+ func (node *ParenExpr) String() string

+ func (node *ParenExpr) TypedInnerExpr() TypedExpr

+ func (ta ParenExpr) ResolvedType() *types.T

+ type ParenSelect struct

+ Select *Select

+ func (*ParenSelect) StatementReturnType() StatementReturnType

+ func (*ParenSelect) StatementTag() string

+ func (*ParenSelect) StatementType() StatementType

+ func (n *ParenSelect) String() string

+ func (node *ParenSelect) Format(ctx *FmtCtx)

+ type ParenTableExpr struct

+ Expr TableExpr

+ func (expr *ParenTableExpr) WalkTableExpr(v Visitor) TableExpr

+ func (node *ParenTableExpr) Format(ctx *FmtCtx)

+ func (node *ParenTableExpr) String() string

+ type ParseContext interface

+ GetCollationEnv func() *CollationEnvironment

+ GetDateHelper func() *pgdate.ParseHelper

+ GetDateStyle func() pgdate.DateStyle

+ GetIntervalStyle func() duration.IntervalStyle

+ GetRelativeParseTime func() time.Time

+ func NewParseContext(relativeParseTime time.Time, opts ...NewParseContextOption) ParseContext

+ type PartitionBy struct

+ Fields NameList

+ List []ListPartition

+ Range []RangePartition

+ func (node *PartitionBy) Format(ctx *FmtCtx)

+ type PartitionByIndex struct

+ func (node *PartitionByIndex) ContainsPartitioningClause() bool

+ func (node *PartitionByIndex) ContainsPartitions() bool

+ type PartitionByTable struct

+ All bool

+ func (node *PartitionByTable) ContainsPartitioningClause() bool

+ func (node *PartitionByTable) ContainsPartitions() bool

+ func (node *PartitionByTable) Format(ctx *FmtCtx)

+ type PartitionByType string

+ const PartitionByList

+ const PartitionByRange

+ type PartitionMaxVal struct

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

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

+ func (node PartitionMaxVal) Format(ctx *FmtCtx)

+ func (node PartitionMaxVal) String() string

+ type PartitionMinVal struct

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

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

+ func (node PartitionMinVal) Format(ctx *FmtCtx)

+ func (node PartitionMinVal) String() string

+ type Persistence int

+ const PersistencePermanent

+ const PersistenceTemporary

+ const PersistenceUnlogged

+ func (p Persistence) IsTemporary() bool

+ func (p Persistence) IsUnlogged() bool

+ type Placeholder struct

+ Idx PlaceholderIdx

+ func NewPlaceholder(name string) (*Placeholder, error)

+ func (d *Placeholder) AmbiguousFormat() bool

+ func (d *Placeholder) Compare(ctx CompareContext, other Datum) int

+ func (d *Placeholder) CompareError(ctx CompareContext, other Datum) (int, error)

+ func (d *Placeholder) IsMax(ctx CompareContext) bool

+ func (d *Placeholder) IsMin(ctx CompareContext) bool

+ func (d *Placeholder) Max(ctx CompareContext) (Datum, bool)

+ func (d *Placeholder) Min(ctx CompareContext) (Datum, bool)

+ func (d *Placeholder) Next(ctx CompareContext) (Datum, bool)

+ func (d *Placeholder) Prev(ctx CompareContext) (Datum, bool)

+ func (d *Placeholder) Size() uintptr

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

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

+ func (node *Placeholder) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *Placeholder) Format(ctx *FmtCtx)

+ func (node *Placeholder) ResolvedType() *types.T

+ func (node *Placeholder) String() string

+ type PlaceholderIdx uint16

+ func (idx PlaceholderIdx) String() string

+ type PlaceholderInfo struct

+ Values QueryArguments

+ func (p *PlaceholderInfo) Assign(src *PlaceholderInfo, numPlaceholders int) error

+ func (p *PlaceholderInfo) Init(numPlaceholders int, typeHints PlaceholderTypes) error

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

+ func (p *PlaceholderInfo) MaybeExtendTypes()

+ func (p *PlaceholderInfo) Value(idx PlaceholderIdx) (TypedExpr, bool)

+ type PlaceholderTypes []*types.T

+ func (pt PlaceholderTypes) AssertAllSet() error

+ func (pt PlaceholderTypes) Identical(other PlaceholderTypes) bool

+ type PlaceholderTypesInfo struct

+ TypeHints PlaceholderTypes

+ Types PlaceholderTypes

+ func (p *PlaceholderTypesInfo) SetType(idx PlaceholderIdx, typ *types.T) error

+ func (p *PlaceholderTypesInfo) Type(idx PlaceholderIdx) (_ *types.T, ok bool, _ error)

+ func (p *PlaceholderTypesInfo) ValueType(idx PlaceholderIdx) (_ *types.T, ok bool)

+ type PlusDateIntOp struct

+ func (op *PlusDateIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusDateIntervalOp struct

+ func (op *PlusDateIntervalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusDateTimeOp struct

+ func (op *PlusDateTimeOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusDateTimeTZOp struct

+ func (op *PlusDateTimeTZOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusDecimalIntOp struct

+ func (op *PlusDecimalIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusDecimalOp struct

+ func (op *PlusDecimalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusDecimalPGLSNOp struct

+ func (op *PlusDecimalPGLSNOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusFloatOp struct

+ func (op *PlusFloatOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusINetIntOp struct

+ func (op *PlusINetIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusIntDateOp struct

+ func (op *PlusIntDateOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusIntDecimalOp struct

+ func (op *PlusIntDecimalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusIntINetOp struct

+ func (op *PlusIntINetOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusIntOp struct

+ func (op *PlusIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusIntervalDateOp struct

+ func (op *PlusIntervalDateOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusIntervalOp struct

+ func (op *PlusIntervalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusIntervalTimeOp struct

+ func (op *PlusIntervalTimeOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusIntervalTimeTZOp struct

+ func (op *PlusIntervalTimeTZOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusIntervalTimestampOp struct

+ func (op *PlusIntervalTimestampOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusIntervalTimestampTZOp struct

+ func (op *PlusIntervalTimestampTZOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusPGLSNDecimalOp struct

+ func (op *PlusPGLSNDecimalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusTimeDateOp struct

+ func (op *PlusTimeDateOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusTimeIntervalOp struct

+ func (op *PlusTimeIntervalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusTimeTZDateOp struct

+ func (op *PlusTimeTZDateOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusTimeTZIntervalOp struct

+ func (op *PlusTimeTZIntervalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusTimestampIntervalOp struct

+ func (op *PlusTimestampIntervalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PlusTimestampTZIntervalOp struct

+ func (op *PlusTimestampTZIntervalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PowDecimalIntOp struct

+ func (op *PowDecimalIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PowDecimalOp struct

+ func (op *PowDecimalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PowFloatOp struct

+ func (op *PowFloatOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PowIntDecimalOp struct

+ func (op *PowIntDecimalOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PowIntOp struct

+ func (op *PowIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type Prepare struct

+ Name Name

+ Statement Statement

+ Types []ResolvableTypeReference

+ func (*Prepare) StatementReturnType() StatementReturnType

+ func (*Prepare) StatementTag() string

+ func (*Prepare) StatementType() StatementType

+ func (n *Prepare) String() string

+ func (node *Prepare) Format(ctx *FmtCtx)

+ type PrependToMaybeNullArrayOp struct

+ Typ *types.T

+ func (op *PrependToMaybeNullArrayOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type PrettyAlignMode int

+ type PrettyCfg struct

+ Align PrettyAlignMode

+ Case func(string) string

+ DoNotNewLineAfterColName bool

+ JSONFmt bool

+ LineWidth int

+ Simplify bool

+ TabWidth int

+ UseTabs bool

+ ValueRedaction bool

+ func DefaultPrettyCfg() PrettyCfg

+ func (p *PrettyCfg) Doc(f NodeFormatter) pretty.Doc

+ func (p *PrettyCfg) Pretty(stmt NodeFormatter) (string, error)

+ type PrimaryKeyConstraint struct

+ StorageParams StorageParams

+ type QualifiedNameResolver interface

+ CurrentDatabase func() string

+ GetQualifiedFunctionNameByID func(ctx context.Context, id int64) (*RoutineName, error)

+ GetQualifiedTableNameByID func(ctx context.Context, id int64, requiredType RequiredTableKind) (*TableName, error)

+ type QualifiedOverload struct

+ Schema string

+ func MakeQualifiedOverload(schema string, overload *Overload) QualifiedOverload

+ type QueryArguments []TypedExpr

+ func (qa QueryArguments) String() string

+ type RShiftINetOp struct

+ func (op *RShiftINetOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type RShiftIntOp struct

+ func (op *RShiftIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type RShiftVarBitIntOp struct

+ func (op *RShiftVarBitIntOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type RangeCond struct

+ From Expr

+ Left Expr

+ Not bool

+ Symmetric bool

+ To Expr

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

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

+ func (node *RangeCond) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *RangeCond) Format(ctx *FmtCtx)

+ func (node *RangeCond) String() string

+ func (node *RangeCond) TypedFrom() TypedExpr

+ func (node *RangeCond) TypedLeftFrom() TypedExpr

+ func (node *RangeCond) TypedLeftTo() TypedExpr

+ func (node *RangeCond) TypedTo() TypedExpr

+ func (ta RangeCond) ResolvedType() *types.T

+ type RangePartition struct

+ From Exprs

+ Name Name

+ Subpartition *PartitionBy

+ To Exprs

+ func (node *RangePartition) Format(ctx *FmtCtx)

+ type RawRows [][]TypedExpr

+ func (r RawRows) Get(i, j int) Expr

+ func (r RawRows) NumCols() int

+ func (r RawRows) NumRows() int

+ type ReadWriteMode int

+ const ReadOnly

+ const ReadWrite

+ const UnspecifiedReadWriteMode

+ func (ro ReadWriteMode) String() string

+ type ReassignOwnedBy struct

+ NewRole RoleSpec

+ OldRoles RoleSpecList

+ func (*ReassignOwnedBy) StatementReturnType() StatementReturnType

+ func (*ReassignOwnedBy) StatementTag() string

+ func (*ReassignOwnedBy) StatementType() StatementType

+ func (n *ReassignOwnedBy) String() string

+ func (node *ReassignOwnedBy) Format(ctx *FmtCtx)

+ type ReferenceAction semenumpb.ForeignKeyAction

+ const Cascade

+ const NoAction

+ const Restrict

+ const SetDefault

+ const SetNull

+ func (x ReferenceAction) String() string

+ type ReferenceActions struct

+ Delete ReferenceAction

+ Update ReferenceAction

+ func (node *ReferenceActions) Format(ctx *FmtCtx)

+ type RefreshDataOption int

+ const RefreshDataClear

+ const RefreshDataDefault

+ const RefreshDataWithData

+ type RefreshMaterializedView struct

+ Concurrently bool

+ Name *UnresolvedObjectName

+ RefreshDataOption RefreshDataOption

+ func (*RefreshMaterializedView) StatementReturnType() StatementReturnType

+ func (*RefreshMaterializedView) StatementTag() string

+ func (*RefreshMaterializedView) StatementType() StatementType

+ func (n *RefreshMaterializedView) String() string

+ func (node *RefreshMaterializedView) Format(ctx *FmtCtx)

+ type RegexpCache struct

+ func NewRegexpCache(size int) *RegexpCache

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

+ func (rc *RegexpCache) Len() int

+ type RegexpCacheKey interface

+ Pattern func() (string, error)

+ type ReleaseSavepoint struct

+ Savepoint Name

+ func (*ReleaseSavepoint) StatementReturnType() StatementReturnType

+ func (*ReleaseSavepoint) StatementTag() string

+ func (*ReleaseSavepoint) StatementType() StatementType

+ func (n *ReleaseSavepoint) String() string

+ func (node *ReleaseSavepoint) Format(ctx *FmtCtx)

+ type Relocate struct

+ Rows *Select

+ SubjectReplicas RelocateSubject

+ TableOrIndex TableIndexName

+ func (*Relocate) StatementReturnType() StatementReturnType

+ func (*Relocate) StatementType() StatementType

+ func (n *Relocate) StatementTag() string

+ func (n *Relocate) String() string

+ func (node *Relocate) Format(ctx *FmtCtx)

+ type RelocateRange struct

+ FromStoreID Expr

+ Rows *Select

+ SubjectReplicas RelocateSubject

+ ToStoreID Expr

+ func (*RelocateRange) StatementReturnType() StatementReturnType

+ func (*RelocateRange) StatementType() StatementType

+ func (n *RelocateRange) Format(ctx *FmtCtx)

+ func (n *RelocateRange) StatementTag() string

+ func (n *RelocateRange) String() string

+ type RelocateSubject int8

+ const RelocateLease

+ const RelocateNonVoters

+ const RelocateVoters

+ func (n *RelocateSubject) Format(ctx *FmtCtx)

+ func (n RelocateSubject) String() string

+ type RenameColumn struct

+ IfExists bool

+ Name Name

+ NewName Name

+ Table TableName

+ func (*RenameColumn) StatementReturnType() StatementReturnType

+ func (*RenameColumn) StatementTag() string

+ func (*RenameColumn) StatementType() StatementType

+ func (n *RenameColumn) String() string

+ func (node *RenameColumn) Format(ctx *FmtCtx)

+ type RenameDatabase struct

+ Name Name

+ NewName Name

+ func (*RenameDatabase) StatementReturnType() StatementReturnType

+ func (*RenameDatabase) StatementTag() string

+ func (*RenameDatabase) StatementType() StatementType

+ func (n *RenameDatabase) String() string

+ func (node *RenameDatabase) Format(ctx *FmtCtx)

+ type RenameIndex struct

+ IfExists bool

+ Index *TableIndexName

+ NewName UnrestrictedName

+ func (*RenameIndex) StatementReturnType() StatementReturnType

+ func (*RenameIndex) StatementTag() string

+ func (*RenameIndex) StatementType() StatementType

+ func (n *RenameIndex) String() string

+ func (node *RenameIndex) Format(ctx *FmtCtx)

+ type RenameTable struct

+ IfExists bool

+ IsMaterialized bool

+ IsSequence bool

+ IsView bool

+ Name *UnresolvedObjectName

+ NewName *UnresolvedObjectName

+ func (*RenameTable) StatementReturnType() StatementReturnType

+ func (*RenameTable) StatementType() StatementType

+ func (n *RenameTable) StatementTag() string

+ func (n *RenameTable) String() string

+ func (node *RenameTable) Format(ctx *FmtCtx)

+ type ReparentDatabase struct

+ Name Name

+ Parent Name

+ func (*ReparentDatabase) StatementReturnType() StatementReturnType

+ func (*ReparentDatabase) StatementTag() string

+ func (*ReparentDatabase) StatementType() StatementType

+ func (n *ReparentDatabase) String() string

+ func (node *ReparentDatabase) Format(ctx *FmtCtx)

+ type ReplicationCutoverTime struct

+ Latest bool

+ Timestamp Expr

+ type RequiredTableKind byte

+ const ResolveAnyTableKind

+ const ResolveRequireSequenceDesc

+ const ResolveRequireTableDesc

+ const ResolveRequireTableOrViewDesc

+ const ResolveRequireViewDesc

+ func (r RequiredTableKind) String() string

+ type ResolvableFunctionReference struct

+ ReferenceByName *UnresolvedObjectName

+ func WrapFunction(n string) ResolvableFunctionReference

+ func (ref *ResolvableFunctionReference) Resolve(ctx context.Context, path SearchPath, resolver FunctionReferenceResolver) (*ResolvedFunctionDefinition, error)

+ type ResolvableTypeReference interface

+ SQLString func() string

+ type ResolvedFunctionDefinition struct

+ Name string

+ Overloads []QualifiedOverload

+ func GetBuiltinFuncDefinition(fName RoutineName, searchPath SearchPath) (*ResolvedFunctionDefinition, error)

+ func GetBuiltinFuncDefinitionOrFail(fName RoutineName, searchPath SearchPath) (*ResolvedFunctionDefinition, error)

+ func GetBuiltinFunctionByOIDOrFail(oid oid.Oid) (*ResolvedFunctionDefinition, error)

+ func QualifyBuiltinFunctionDefinition(def *FunctionDefinition, schema string) *ResolvedFunctionDefinition

+ func (fd *ResolvedFunctionDefinition) Format(ctx *FmtCtx)

+ func (fd *ResolvedFunctionDefinition) GetClass() (FunctionClass, error)

+ func (fd *ResolvedFunctionDefinition) GetHasSequenceArguments() (bool, error)

+ func (fd *ResolvedFunctionDefinition) GetReturnLabel() ([]string, error)

+ func (fd *ResolvedFunctionDefinition) MatchOverload(paramTypes []*types.T, explicitSchema string, searchPath SearchPath, ...) (QualifiedOverload, error)

+ func (fd *ResolvedFunctionDefinition) MergeWith(another *ResolvedFunctionDefinition) (*ResolvedFunctionDefinition, error)

+ func (fd *ResolvedFunctionDefinition) String() string

+ type Restore struct

+ AsOf AsOfClause

+ DescriptorCoverage DescriptorCoverage

+ From []StringOrPlaceholderOptList

+ Options RestoreOptions

+ Subdir Expr

+ Targets BackupTargetList

+ func (*Restore) StatementReturnType() StatementReturnType

+ func (*Restore) StatementTag() string

+ func (*Restore) StatementType() StatementType

+ func (n *Restore) String() string

+ func (node *Restore) Format(ctx *FmtCtx)

+ type RestoreOptions struct

+ AsTenant Expr

+ DebugPauseOn Expr

+ DecryptionKMSURI StringOrPlaceholderOptList

+ Detached bool

+ EncryptionPassphrase Expr

+ ExecutionLocality Expr

+ ExperimentalOnline bool

+ ForceTenantID Expr

+ IncludeAllSecondaryTenants Expr

+ IncrementalStorage StringOrPlaceholderOptList

+ IntoDB Expr

+ NewDBName Expr

+ RemoveRegions bool

+ SchemaOnly bool

+ SkipLocalitiesCheck bool

+ SkipMissingFKs bool

+ SkipMissingSequenceOwners bool

+ SkipMissingSequences bool

+ SkipMissingUDFs bool

+ SkipMissingViews bool

+ UnsafeRestoreIncompatibleVersion bool

+ VerifyData bool

+ func (o *RestoreOptions) CombineWith(other *RestoreOptions) error

+ func (o *RestoreOptions) Format(ctx *FmtCtx)

+ func (o RestoreOptions) IsDefault() bool

+ type ReturnTyper func(args []TypedExpr) *types.T

+ func ArrayOfFirstNonNullReturnType() ReturnTyper

+ func FirstNonNullReturnType() ReturnTyper

+ func FixedReturnType(typ *types.T) ReturnTyper

+ func IdentityReturnType(idx int) ReturnTyper

+ type ReturningClause interface

+ type ReturningExprs SelectExprs

+ func (r *ReturningExprs) Format(ctx *FmtCtx)

+ type ReturningNothing struct

+ func (*ReturningNothing) Format(ctx *FmtCtx)

+ type Revoke struct

+ GrantOptionFor bool

+ Grantees RoleSpecList

+ Privileges privilege.List

+ Targets GrantTargetList

+ func (*Revoke) StatementReturnType() StatementReturnType

+ func (*Revoke) StatementTag() string

+ func (*Revoke) StatementType() StatementType

+ func (n *Revoke) String() string

+ func (node *Revoke) Format(ctx *FmtCtx)

+ type RevokeRole struct

+ AdminOption bool

+ Members RoleSpecList

+ Roles NameList

+ func (*RevokeRole) StatementReturnType() StatementReturnType

+ func (*RevokeRole) StatementTag() string

+ func (*RevokeRole) StatementType() StatementType

+ func (n *RevokeRole) String() string

+ func (node *RevokeRole) Format(ctx *FmtCtx)

+ type RoleSpec struct

+ Name string

+ RoleSpecType RoleSpecType

+ func MakeRoleSpecWithRoleName(name string) RoleSpec

+ func (r *RoleSpec) Format(ctx *FmtCtx)

+ func (r RoleSpec) Undefined() bool

+ type RoleSpecList []RoleSpec

+ func (l *RoleSpecList) Format(ctx *FmtCtx)

+ type RoleSpecType int

+ const CurrentUser

+ const RoleName

+ const SessionUser

+ func (r RoleSpecType) String() string

+ type RollbackToSavepoint struct

+ Savepoint Name

+ func (*RollbackToSavepoint) StatementReturnType() StatementReturnType

+ func (*RollbackToSavepoint) StatementTag() string

+ func (*RollbackToSavepoint) StatementType() StatementType

+ func (n *RollbackToSavepoint) String() string

+ func (node *RollbackToSavepoint) Format(ctx *FmtCtx)

+ type RollbackTransaction struct

+ func (*RollbackTransaction) StatementReturnType() StatementReturnType

+ func (*RollbackTransaction) StatementTag() string

+ func (*RollbackTransaction) StatementType() StatementType

+ func (n *RollbackTransaction) String() string

+ func (node *RollbackTransaction) Format(ctx *FmtCtx)

+ type RoutineBody struct

+ Stmts Statements

+ type RoutineBodyStr string

+ func (node RoutineBodyStr) Format(ctx *FmtCtx)

+ type RoutineExceptionHandler struct

+ Actions []*RoutineExpr

+ Codes []pgcode.Code

+ type RoutineExecFactory interface

+ type RoutineExpr struct

+ Args TypedExprs

+ BlockState *BlockState

+ CachedResult Datum

+ CalledOnNullInput bool

+ CursorDeclaration *RoutineOpenCursor

+ EnableStepping bool

+ ForEachPlan RoutinePlanGenerator

+ Generator bool

+ MultiColOutput bool

+ Name string

+ Procedure bool

+ TailCall bool

+ Typ *types.T

+ func NewTypedRoutineExpr(name string, args TypedExprs, gen RoutinePlanGenerator, typ *types.T, ...) *RoutineExpr

+ func (node *RoutineExpr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *RoutineExpr) Format(ctx *FmtCtx)

+ func (node *RoutineExpr) ResolvedType() *types.T

+ func (node *RoutineExpr) String() string

+ func (node *RoutineExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error)

+ func (node *RoutineExpr) Walk(v Visitor) Expr

+ type RoutineLanguage string

+ const RoutineLangC

+ const RoutineLangPLpgSQL

+ const RoutineLangSQL

+ const RoutineLangUnknown

+ func AsRoutineLanguage(lang string) (RoutineLanguage, error)

+ func (node RoutineLanguage) Format(ctx *FmtCtx)

+ type RoutineLeakproof bool

+ func (node RoutineLeakproof) Format(ctx *FmtCtx)

+ type RoutineName struct

+ func MakeQualifiedRoutineName(db string, sc string, fn string) RoutineName

+ func MakeRoutineNameFromPrefix(prefix ObjectNamePrefix, object Name) RoutineName

+ func (f *RoutineName) FQString() string

+ func (f *RoutineName) Format(ctx *FmtCtx)

+ func (f *RoutineName) String() string

+ func (o *RoutineName) Object() string

+ func (o *RoutineName) ToUnresolvedObjectName() *UnresolvedObjectName

+ type RoutineNullInputBehavior int

+ const RoutineCalledOnNullInput

+ const RoutineReturnsNullOnNullInput

+ const RoutineStrict

+ func (node RoutineNullInputBehavior) Format(ctx *FmtCtx)

+ type RoutineObj struct

+ FuncName RoutineName

+ Params RoutineParams

+ func (node *RoutineObj) Format(ctx *FmtCtx)

+ func (node RoutineObj) ParamTypes(ctx context.Context, res TypeReferenceResolver) ([]*types.T, error)

+ type RoutineObjs []RoutineObj

+ func (node RoutineObjs) Format(ctx *FmtCtx)

+ type RoutineOpenCursor struct

+ CursorSQL string

+ NameArgIdx int

+ Scroll CursorScrollOption

+ type RoutineOption interface

+ type RoutineOptions []RoutineOption

+ type RoutineParam struct

+ Class RoutineParamClass

+ DefaultVal Expr

+ Name Name

+ Type ResolvableTypeReference

+ func (node *RoutineParam) Format(ctx *FmtCtx)

+ type RoutineParamClass int

+ const RoutineParamIn

+ const RoutineParamInOut

+ const RoutineParamOut

+ const RoutineParamVariadic

+ type RoutineParams []RoutineParam

+ func (node RoutineParams) Format(ctx *FmtCtx)

+ type RoutinePlan interface

+ type RoutinePlanGeneratedFunc func(plan RoutinePlan, isFinalPlan bool) error

+ type RoutinePlanGenerator func(_ context.Context, _ RoutineExecFactory, args Datums, ...) error

+ type RoutineReturn struct

+ ReturnVal Expr

+ func (*RoutineReturn) StatementReturnType() StatementReturnType

+ func (*RoutineReturn) StatementTag() string

+ func (*RoutineReturn) StatementType() StatementType

+ func (n *RoutineReturn) String() string

+ func (node *RoutineReturn) Format(ctx *FmtCtx)

+ type RoutineReturnType struct

+ SetOf bool

+ Type ResolvableTypeReference

+ type RoutineType uint8

+ const BuiltinRoutine

+ const ProcedureRoutine

+ const UDFRoutine

+ func (t RoutineType) String() string

+ type RoutineVolatility int

+ const RoutineImmutable

+ const RoutineStable

+ const RoutineVolatile

+ func GetRoutineVolatility(options RoutineOptions) RoutineVolatility

+ func (node RoutineVolatility) Format(ctx *FmtCtx)

+ type RowsFromExpr struct

+ Items Exprs

+ func (expr *RowsFromExpr) WalkTableExpr(v Visitor) TableExpr

+ func (node *RowsFromExpr) Format(ctx *FmtCtx)

+ type SQLFnOverload interface

+ SQLFn func()

+ type Savepoint struct

+ Name Name

+ func (*Savepoint) StatementReturnType() StatementReturnType

+ func (*Savepoint) StatementTag() string

+ func (*Savepoint) StatementType() StatementType

+ func (n *Savepoint) String() string

+ func (node *Savepoint) Format(ctx *FmtCtx)

+ type ScalarAncestors byte

+ const CallAncestor

+ const ConditionalAncestor

+ const FuncExprAncestor

+ const WindowFuncAncestor

+ func (s *ScalarAncestors) PopTo(orig ScalarAncestors)

+ func (s *ScalarAncestors) Push(other ScalarAncestors)

+ func (s ScalarAncestors) Has(other ScalarAncestors) bool

+ type ScalarProperties struct

+ SeenAggregate bool

+ SeenGenerator bool

+ SeenWindowApplication bool

+ func (sp *ScalarProperties) Clear()

+ type Scatter struct

+ From Exprs

+ TableOrIndex TableIndexName

+ To Exprs

+ func (*Scatter) StatementReturnType() StatementReturnType

+ func (*Scatter) StatementTag() string

+ func (*Scatter) StatementType() StatementType

+ func (n *Scatter) String() string

+ func (node *Scatter) Format(ctx *FmtCtx)

+ type ScheduleCommand int

+ const DropSchedule

+ const PauseSchedule

+ const ResumeSchedule

+ func (c ScheduleCommand) String() string

+ type ScheduleState int

+ const ActiveSchedules

+ const PausedSchedules

+ const SpecifiedSchedules

+ func (s ScheduleState) Format(ctx *FmtCtx)

+ type ScheduledBackup struct

+ BackupOptions BackupOptions

+ FullBackup *FullBackupClause

+ Recurrence Expr

+ ScheduleLabelSpec LabelSpec

+ ScheduleOptions KVOptions

+ Targets *BackupTargetList

+ To StringOrPlaceholderOptList

+ func (*ScheduledBackup) StatementReturnType() StatementReturnType

+ func (*ScheduledBackup) StatementTag() string

+ func (*ScheduledBackup) StatementType() StatementType

+ func (n *ScheduledBackup) String() string

+ func (node *ScheduledBackup) Format(ctx *FmtCtx)

+ func (node ScheduledBackup) Coverage() DescriptorCoverage

+ type ScheduledChangefeed struct

+ Recurrence Expr

+ ScheduleLabelSpec LabelSpec

+ ScheduleOptions KVOptions

+ func (*ScheduledChangefeed) StatementReturnType() StatementReturnType

+ func (*ScheduledChangefeed) StatementType() StatementType

+ func (n *ScheduledChangefeed) StatementTag() string

+ func (node *ScheduledChangefeed) Format(ctx *FmtCtx)

+ type ScheduledJobExecutorType int

+ const InvalidExecutor

+ const ScheduledBackupExecutor

+ const ScheduledChangefeedExecutor

+ const ScheduledRowLevelTTLExecutor

+ const ScheduledSQLStatsCompactionExecutor

+ const ScheduledSchemaTelemetryExecutor

+ func (t ScheduledJobExecutorType) InternalName() string

+ func (t ScheduledJobExecutorType) UserName() string

+ type SchemaExprContext string

+ const AlterColumnTypeUsingExpr

+ const CheckConstraintExpr

+ const ColumnDefaultExprInAddColumn

+ const ColumnDefaultExprInNewTable

+ const ColumnDefaultExprInNewView

+ const ColumnDefaultExprInSetDefault

+ const ColumnOnUpdateExpr

+ const ExpressionIndexElementExpr

+ const IndexPredicateExpr

+ const StoredComputedColumnExpr

+ const TTLDefaultExpr

+ const TTLExpirationExpr

+ const TTLUpdateExpr

+ const UniqueWithoutIndexPredicateExpr

+ const VirtualComputedColumnExpr

+ func ComputedColumnExprContext(isVirtual bool) SchemaExprContext

+ type SchemaFeatureName string

+ func GetSchemaFeatureNameFromStmt(stmt Statement) SchemaFeatureName

+ type Scrub struct

+ AsOf AsOfClause

+ Database Name

+ Options ScrubOptions

+ Table *UnresolvedObjectName

+ Typ ScrubType

+ func (*Scrub) StatementReturnType() StatementReturnType

+ func (*Scrub) StatementType() StatementType

+ func (n *Scrub) Format(ctx *FmtCtx)

+ func (n *Scrub) StatementTag() string

+ func (n *Scrub) String() string

+ type ScrubOption interface

+ type ScrubOptionConstraint struct

+ ConstraintNames NameList

+ func (n *ScrubOptionConstraint) Format(ctx *FmtCtx)

+ func (n *ScrubOptionConstraint) String() string

+ type ScrubOptionIndex struct

+ IndexNames NameList

+ func (n *ScrubOptionIndex) Format(ctx *FmtCtx)

+ func (n *ScrubOptionIndex) String() string

+ type ScrubOptionPhysical struct

+ func (n *ScrubOptionPhysical) Format(ctx *FmtCtx)

+ func (n *ScrubOptionPhysical) String() string

+ type ScrubOptions []ScrubOption

+ func (n *ScrubOptions) Format(ctx *FmtCtx)

+ func (n *ScrubOptions) String() string

+ type ScrubType int

+ type SearchPath interface

+ GetSchema func(ord int) string

+ NumElements func() int

+ var EmptySearchPath SearchPath = emptySearchPath{}

+ type Select struct

+ Limit *Limit

+ Locking LockingClause

+ OrderBy OrderBy

+ Select SelectStatement

+ With *With

+ func (*Select) StatementReturnType() StatementReturnType

+ func (*Select) StatementTag() string

+ func (*Select) StatementType() StatementType

+ func (n *Select) String() string

+ func (node *Select) Format(ctx *FmtCtx)

+ type SelectClause struct

+ Distinct bool

+ DistinctOn DistinctOn

+ Exprs SelectExprs

+ From From

+ GroupBy GroupBy

+ Having *Where

+ TableSelect bool

+ Where *Where

+ Window Window

+ func (*SelectClause) StatementReturnType() StatementReturnType

+ func (*SelectClause) StatementTag() string

+ func (*SelectClause) StatementType() StatementType

+ func (n *SelectClause) String() string

+ func (node *SelectClause) Format(ctx *FmtCtx)

+ type SelectExpr struct

+ As UnrestrictedName

+ Expr Expr

+ func StarSelectExpr() SelectExpr

+ func (node *SelectExpr) Format(ctx *FmtCtx)

+ func (node *SelectExpr) NormalizeTopLevelVarName() error

+ type SelectExprs []SelectExpr

+ func (node *SelectExprs) Format(ctx *FmtCtx)

+ type SelectStatement interface

+ type SemaContext struct

+ Annotations Annotations

+ DateStyle pgdate.DateStyle

+ FunctionResolver FunctionReferenceResolver

+ IVarContainer IndexedVarContainer

+ IntervalStyle duration.IntervalStyle

+ NameResolver QualifiedNameResolver

+ Placeholders PlaceholderInfo

+ Properties SemaProperties

+ SearchPath SearchPath

+ TypeResolver TypeReferenceResolver

+ UnsupportedTypeChecker UnsupportedTypeChecker

+ func MakeSemaContext() SemaContext

+ func (sc *SemaContext) GetTypeResolver() TypeReferenceResolver

+ func (sc *SemaContext) TypeCheckContext() string

+ type SemaProperties struct

+ Ancestors ScalarAncestors

+ Derived ScalarProperties

+ func (s *SemaProperties) IsSet(rejectFlags SemaRejectFlags) bool

+ func (s *SemaProperties) Reject(rejectFlags SemaRejectFlags)

+ func (s *SemaProperties) Require(context string, rejectFlags SemaRejectFlags)

+ func (s *SemaProperties) Restore(orig SemaProperties)

+ type SemaRejectFlags int

+ const RejectAggregates

+ const RejectGenerators

+ const RejectNestedAggregates

+ const RejectNestedGenerators

+ const RejectNestedWindowFunctions

+ const RejectProcedures

+ const RejectSpecial

+ const RejectStableOperators

+ const RejectSubqueries

+ const RejectVolatileFunctions

+ const RejectWindowApplications

+ type SequenceOption struct

+ AsIntegerType *types.T

+ ColumnItemVal *ColumnItem

+ IntVal *int64

+ Name string

+ OptionalWord bool

+ type SequenceOptions []SequenceOption

+ func (node *SequenceOptions) Format(ctx *FmtCtx)

+ type SetClusterSetting struct

+ Name string

+ Value Expr

+ func (*SetClusterSetting) StatementReturnType() StatementReturnType

+ func (*SetClusterSetting) StatementTag() string

+ func (*SetClusterSetting) StatementType() StatementType

+ func (n *SetClusterSetting) String() string

+ func (node *SetClusterSetting) Format(ctx *FmtCtx)

+ type SetSessionAuthorizationDefault struct

+ func (*SetSessionAuthorizationDefault) StatementReturnType() StatementReturnType

+ func (*SetSessionAuthorizationDefault) StatementTag() string

+ func (*SetSessionAuthorizationDefault) StatementType() StatementType

+ func (n *SetSessionAuthorizationDefault) String() string

+ func (node *SetSessionAuthorizationDefault) Format(ctx *FmtCtx)

+ type SetSessionCharacteristics struct

+ Modes TransactionModes

+ func (*SetSessionCharacteristics) StatementReturnType() StatementReturnType

+ func (*SetSessionCharacteristics) StatementTag() string

+ func (*SetSessionCharacteristics) StatementType() StatementType

+ func (n *SetSessionCharacteristics) String() string

+ func (node *SetSessionCharacteristics) Format(ctx *FmtCtx)

+ type SetTracing struct

+ Values Exprs

+ func (*SetTracing) StatementReturnType() StatementReturnType

+ func (*SetTracing) StatementTag() string

+ func (*SetTracing) StatementType() StatementType

+ func (n *SetTracing) String() string

+ func (node *SetTracing) Format(ctx *FmtCtx)

+ type SetTransaction struct

+ Modes TransactionModes

+ func (*SetTransaction) StatementReturnType() StatementReturnType

+ func (*SetTransaction) StatementTag() string

+ func (*SetTransaction) StatementType() StatementType

+ func (n *SetTransaction) String() string

+ func (node *SetTransaction) Format(ctx *FmtCtx)

+ type SetVar struct

+ Local bool

+ Name string

+ Reset bool

+ ResetAll bool

+ SetRow bool

+ Values Exprs

+ func (*SetVar) StatementReturnType() StatementReturnType

+ func (*SetVar) StatementType() StatementType

+ func (n *SetVar) StatementTag() string

+ func (n *SetVar) String() string

+ func (node *SetVar) Format(ctx *FmtCtx)

+ type SetZoneConfig struct

+ AllIndexes bool

+ func (*SetZoneConfig) StatementReturnType() StatementReturnType

+ func (*SetZoneConfig) StatementTag() string

+ func (*SetZoneConfig) StatementType() StatementType

+ func (n *SetZoneConfig) String() string

+ func (node *SetZoneConfig) Format(ctx *FmtCtx)

+ type ShardedIndexDef struct

+ ShardBuckets Expr

+ func (node *ShardedIndexDef) Format(ctx *FmtCtx)

+ type ShardedPrimaryKeyConstraint struct

+ ShardBuckets Expr

+ Sharded bool

+ StorageParams StorageParams

+ type ShowBackup struct

+ Details ShowBackupDetails

+ From bool

+ InCollection StringOrPlaceholderOptList

+ Options ShowBackupOptions

+ Path Expr

+ func (*ShowBackup) StatementReturnType() StatementReturnType

+ func (*ShowBackup) StatementTag() string

+ func (*ShowBackup) StatementType() StatementType

+ func (n *ShowBackup) String() string

+ func (node *ShowBackup) Format(ctx *FmtCtx)

+ type ShowBackupDetails int

+ const BackupConnectionTest

+ const BackupDefaultDetails

+ const BackupFileDetails

+ const BackupRangeDetails

+ const BackupSchemaDetails

+ const BackupValidateDetails

+ type ShowBackupOptions struct

+ AsJson bool

+ CheckConnectionConcurrency Expr

+ CheckConnectionDuration Expr

+ CheckConnectionTransferSize Expr

+ CheckFiles bool

+ DebugIDs bool

+ DebugMetadataSST bool

+ DecryptionKMSURI StringOrPlaceholderOptList

+ EncryptionInfoDir Expr

+ EncryptionPassphrase Expr

+ IncrementalStorage StringOrPlaceholderOptList

+ Privileges bool

+ SkipSize bool

+ func (o *ShowBackupOptions) CombineWith(other *ShowBackupOptions) error

+ func (o *ShowBackupOptions) Format(ctx *FmtCtx)

+ func (o ShowBackupOptions) IsDefault() bool

+ type ShowChangefeedJobs struct

+ Jobs *Select

+ func (*ShowChangefeedJobs) StatementReturnType() StatementReturnType

+ func (*ShowChangefeedJobs) StatementTag() string

+ func (*ShowChangefeedJobs) StatementType() StatementType

+ func (n *ShowChangefeedJobs) String() string

+ func (node *ShowChangefeedJobs) Format(ctx *FmtCtx)

+ type ShowClusterSetting struct

+ Name string

+ func (*ShowClusterSetting) StatementReturnType() StatementReturnType

+ func (*ShowClusterSetting) StatementTag() string

+ func (*ShowClusterSetting) StatementType() StatementType

+ func (n *ShowClusterSetting) String() string

+ func (node *ShowClusterSetting) Format(ctx *FmtCtx)

+ type ShowClusterSettingList struct

+ All bool

+ func (*ShowClusterSettingList) StatementReturnType() StatementReturnType

+ func (*ShowClusterSettingList) StatementTag() string

+ func (*ShowClusterSettingList) StatementType() StatementType

+ func (n *ShowClusterSettingList) String() string

+ func (node *ShowClusterSettingList) Format(ctx *FmtCtx)

+ type ShowColumns struct

+ Table *UnresolvedObjectName

+ WithComment bool

+ func (*ShowColumns) StatementReturnType() StatementReturnType

+ func (*ShowColumns) StatementTag() string

+ func (*ShowColumns) StatementType() StatementType

+ func (n *ShowColumns) String() string

+ func (node *ShowColumns) Format(ctx *FmtCtx)

+ type ShowCommitTimestamp struct

+ func (*ShowCommitTimestamp) StatementReturnType() StatementReturnType

+ func (*ShowCommitTimestamp) StatementTag() string

+ func (*ShowCommitTimestamp) StatementType() StatementType

+ func (n *ShowCommitTimestamp) String() string

+ func (s ShowCommitTimestamp) Format(ctx *FmtCtx)

+ type ShowCompletions struct

+ Offset *NumVal

+ Statement *StrVal

+ func (*ShowCompletions) StatementReturnType() StatementReturnType

+ func (*ShowCompletions) StatementTag() string

+ func (*ShowCompletions) StatementType() StatementType

+ func (n *ShowCompletions) String() string

+ func (s ShowCompletions) Format(ctx *FmtCtx)

+ type ShowConstraints struct

+ Table *UnresolvedObjectName

+ WithComment bool

+ func (*ShowConstraints) StatementReturnType() StatementReturnType

+ func (*ShowConstraints) StatementTag() string

+ func (*ShowConstraints) StatementType() StatementType

+ func (n *ShowConstraints) String() string

+ func (node *ShowConstraints) Format(ctx *FmtCtx)

+ type ShowCreate struct

+ FmtOpt ShowCreateFormatOption

+ Mode ShowCreateMode

+ Name *UnresolvedObjectName

+ func (*ShowCreate) StatementReturnType() StatementReturnType

+ func (*ShowCreate) StatementTag() string

+ func (*ShowCreate) StatementType() StatementType

+ func (n *ShowCreate) String() string

+ func (node *ShowCreate) Format(ctx *FmtCtx)

+ type ShowCreateAllSchemas struct

+ func (*ShowCreateAllSchemas) StatementReturnType() StatementReturnType

+ func (*ShowCreateAllSchemas) StatementTag() string

+ func (*ShowCreateAllSchemas) StatementType() StatementType

+ func (n *ShowCreateAllSchemas) String() string

+ func (node *ShowCreateAllSchemas) Format(ctx *FmtCtx)

+ type ShowCreateAllTables struct

+ func (*ShowCreateAllTables) StatementReturnType() StatementReturnType

+ func (*ShowCreateAllTables) StatementTag() string

+ func (*ShowCreateAllTables) StatementType() StatementType

+ func (n *ShowCreateAllTables) String() string

+ func (node *ShowCreateAllTables) Format(ctx *FmtCtx)

+ type ShowCreateAllTypes struct

+ func (*ShowCreateAllTypes) StatementReturnType() StatementReturnType

+ func (*ShowCreateAllTypes) StatementTag() string

+ func (*ShowCreateAllTypes) StatementType() StatementType

+ func (n *ShowCreateAllTypes) String() string

+ func (node *ShowCreateAllTypes) Format(ctx *FmtCtx)

+ type ShowCreateExternalConnections struct

+ ConnectionLabel Expr

+ func (*ShowCreateExternalConnections) StatementReturnType() StatementReturnType

+ func (*ShowCreateExternalConnections) StatementTag() string

+ func (*ShowCreateExternalConnections) StatementType() StatementType

+ func (n *ShowCreateExternalConnections) String() string

+ func (node *ShowCreateExternalConnections) Format(ctx *FmtCtx)

+ type ShowCreateFormatOption int

+ const ShowCreateFormatOptionNone

+ const ShowCreateFormatOptionRedactedValues

+ type ShowCreateMode int

+ const ShowCreateModeDatabase

+ const ShowCreateModeIndexes

+ const ShowCreateModeSecondaryIndexes

+ const ShowCreateModeSequence

+ const ShowCreateModeTable

+ const ShowCreateModeView

+ type ShowCreateRoutine struct

+ Name ResolvableFunctionReference

+ Procedure bool

+ func (*ShowCreateRoutine) StatementReturnType() StatementReturnType

+ func (*ShowCreateRoutine) StatementType() StatementType

+ func (n *ShowCreateRoutine) StatementTag() string

+ func (n *ShowCreateRoutine) String() string

+ func (node *ShowCreateRoutine) Format(ctx *FmtCtx)

+ type ShowCreateSchedules struct

+ ScheduleID Expr

+ func (*ShowCreateSchedules) StatementReturnType() StatementReturnType

+ func (*ShowCreateSchedules) StatementTag() string

+ func (*ShowCreateSchedules) StatementType() StatementType

+ func (n *ShowCreateSchedules) String() string

+ func (node *ShowCreateSchedules) Format(ctx *FmtCtx)

+ type ShowDatabaseIndexes struct

+ Database Name

+ WithComment bool

+ func (*ShowDatabaseIndexes) StatementReturnType() StatementReturnType

+ func (*ShowDatabaseIndexes) StatementTag() string

+ func (*ShowDatabaseIndexes) StatementType() StatementType

+ func (n *ShowDatabaseIndexes) String() string

+ func (node *ShowDatabaseIndexes) Format(ctx *FmtCtx)

+ type ShowDatabases struct

+ WithComment bool

+ func (*ShowDatabases) StatementReturnType() StatementReturnType

+ func (*ShowDatabases) StatementTag() string

+ func (*ShowDatabases) StatementType() StatementType

+ func (n *ShowDatabases) String() string

+ func (node *ShowDatabases) Format(ctx *FmtCtx)

+ type ShowDefaultPrivileges struct

+ ForAllRoles bool

+ ForGrantee bool

+ Roles RoleSpecList

+ Schema Name

+ func (*ShowDefaultPrivileges) StatementReturnType() StatementReturnType

+ func (*ShowDefaultPrivileges) StatementTag() string

+ func (*ShowDefaultPrivileges) StatementType() StatementType

+ func (n *ShowDefaultPrivileges) Format(ctx *FmtCtx)

+ func (n *ShowDefaultPrivileges) String() string

+ type ShowEnums struct

+ func (*ShowEnums) StatementReturnType() StatementReturnType

+ func (*ShowEnums) StatementTag() string

+ func (*ShowEnums) StatementType() StatementType

+ func (n *ShowEnums) String() string

+ func (node *ShowEnums) Format(ctx *FmtCtx)

+ type ShowFingerprints struct

+ Table *UnresolvedObjectName

+ TenantSpec *TenantSpec

+ func (*ShowFingerprints) StatementReturnType() StatementReturnType

+ func (*ShowFingerprints) StatementTag() string

+ func (*ShowFingerprints) StatementType() StatementType

+ func (n *ShowFingerprints) String() string

+ func (node *ShowFingerprints) Format(ctx *FmtCtx)

+ type ShowFullTableScans struct

+ func (*ShowFullTableScans) StatementReturnType() StatementReturnType

+ func (*ShowFullTableScans) StatementTag() string

+ func (*ShowFullTableScans) StatementType() StatementType

+ func (n *ShowFullTableScans) String() string

+ func (node *ShowFullTableScans) Format(ctx *FmtCtx)

+ type ShowGrants struct

+ Grantees RoleSpecList

+ Targets *GrantTargetList

+ func (*ShowGrants) StatementReturnType() StatementReturnType

+ func (*ShowGrants) StatementTag() string

+ func (*ShowGrants) StatementType() StatementType

+ func (n *ShowGrants) String() string

+ func (node *ShowGrants) Format(ctx *FmtCtx)

+ type ShowHistogram struct

+ HistogramID int64

+ func (*ShowHistogram) StatementReturnType() StatementReturnType

+ func (*ShowHistogram) StatementTag() string

+ func (*ShowHistogram) StatementType() StatementType

+ func (n *ShowHistogram) String() string

+ func (node *ShowHistogram) Format(ctx *FmtCtx)

+ type ShowIndexes struct

+ Table *UnresolvedObjectName

+ WithComment bool

+ func (*ShowIndexes) StatementReturnType() StatementReturnType

+ func (*ShowIndexes) StatementTag() string

+ func (*ShowIndexes) StatementType() StatementType

+ func (n *ShowIndexes) String() string

+ func (node *ShowIndexes) Format(ctx *FmtCtx)

+ type ShowJobOptions struct

+ ExecutionDetails bool

+ func (s *ShowJobOptions) CombineWith(other *ShowJobOptions) error

+ func (s *ShowJobOptions) Format(ctx *FmtCtx)

+ type ShowJobs struct

+ Automatic bool

+ Block bool

+ Jobs *Select

+ Options *ShowJobOptions

+ Schedules *Select

+ func (*ShowJobs) StatementReturnType() StatementReturnType

+ func (*ShowJobs) StatementTag() string

+ func (*ShowJobs) StatementType() StatementType

+ func (n *ShowJobs) String() string

+ func (node *ShowJobs) Format(ctx *FmtCtx)

+ type ShowLastQueryStatistics struct

+ Columns NameList

+ func (*ShowLastQueryStatistics) StatementReturnType() StatementReturnType

+ func (*ShowLastQueryStatistics) StatementTag() string

+ func (*ShowLastQueryStatistics) StatementType() StatementType

+ func (n *ShowLastQueryStatistics) String() string

+ func (node *ShowLastQueryStatistics) Format(ctx *FmtCtx)

+ type ShowPartitions struct

+ Database Name

+ Index TableIndexName

+ IsDB bool

+ IsIndex bool

+ IsTable bool

+ Table *UnresolvedObjectName

+ func (*ShowPartitions) StatementReturnType() StatementReturnType

+ func (*ShowPartitions) StatementTag() string

+ func (*ShowPartitions) StatementType() StatementType

+ func (n *ShowPartitions) String() string

+ func (node *ShowPartitions) Format(ctx *FmtCtx)

+ type ShowQueries struct

+ All bool

+ Cluster bool

+ func (*ShowQueries) StatementReturnType() StatementReturnType

+ func (*ShowQueries) StatementTag() string

+ func (*ShowQueries) StatementType() StatementType

+ func (n *ShowQueries) String() string

+ func (node *ShowQueries) Format(ctx *FmtCtx)

+ type ShowRangeForRow struct

+ Row Exprs

+ TableOrIndex TableIndexName

+ func (*ShowRangeForRow) StatementReturnType() StatementReturnType

+ func (*ShowRangeForRow) StatementTag() string

+ func (*ShowRangeForRow) StatementType() StatementType

+ func (n *ShowRangeForRow) String() string

+ func (node *ShowRangeForRow) Format(ctx *FmtCtx)

+ type ShowRanges struct

+ DatabaseName Name

+ Options *ShowRangesOptions

+ Source ShowRangesSource

+ TableOrIndex TableIndexName

+ func (*ShowRanges) StatementReturnType() StatementReturnType

+ func (*ShowRanges) StatementTag() string

+ func (*ShowRanges) StatementType() StatementType

+ func (n *ShowRanges) String() string

+ func (node *ShowRanges) Format(ctx *FmtCtx)

+ type ShowRangesMode int8

+ const ExpandIndexes

+ const ExpandTables

+ const UniqueRanges

+ type ShowRangesOptions struct

+ Details bool

+ Explain bool

+ Keys bool

+ Mode ShowRangesMode

+ func (node *ShowRangesOptions) Format(ctx *FmtCtx)

+ type ShowRangesSource int8

+ const ShowRangesCluster

+ const ShowRangesCurrentDatabase

+ const ShowRangesDatabase

+ const ShowRangesIndex

+ const ShowRangesTable

+ type ShowRegions struct

+ DatabaseName Name

+ ShowRegionsFrom ShowRegionsFrom

+ func (*ShowRegions) StatementReturnType() StatementReturnType

+ func (*ShowRegions) StatementTag() string

+ func (*ShowRegions) StatementType() StatementType

+ func (n *ShowRegions) String() string

+ func (node *ShowRegions) Format(ctx *FmtCtx)

+ type ShowRegionsFrom int

+ const ShowRegionsFromAllDatabases

+ const ShowRegionsFromCluster

+ const ShowRegionsFromDatabase

+ const ShowRegionsFromDefault

+ const ShowSuperRegionsFromDatabase

+ type ShowRoleGrants struct

+ Grantees RoleSpecList

+ Roles RoleSpecList

+ func (*ShowRoleGrants) StatementReturnType() StatementReturnType

+ func (*ShowRoleGrants) StatementTag() string

+ func (*ShowRoleGrants) StatementType() StatementType

+ func (n *ShowRoleGrants) String() string

+ func (node *ShowRoleGrants) Format(ctx *FmtCtx)

+ type ShowRoles struct

+ func (*ShowRoles) StatementReturnType() StatementReturnType

+ func (*ShowRoles) StatementTag() string

+ func (*ShowRoles) StatementType() StatementType

+ func (n *ShowRoles) String() string

+ func (node *ShowRoles) Format(ctx *FmtCtx)

+ type ShowRoutines struct

+ Procedure bool

+ func (*ShowRoutines) StatementReturnType() StatementReturnType

+ func (*ShowRoutines) StatementType() StatementType

+ func (n *ShowRoutines) StatementTag() string

+ func (n *ShowRoutines) String() string

+ func (node *ShowRoutines) Format(ctx *FmtCtx)

+ type ShowSavepointStatus struct

+ func (*ShowSavepointStatus) StatementReturnType() StatementReturnType

+ func (*ShowSavepointStatus) StatementTag() string

+ func (*ShowSavepointStatus) StatementType() StatementType

+ func (n *ShowSavepointStatus) String() string

+ func (node *ShowSavepointStatus) Format(ctx *FmtCtx)

+ type ShowSchedules struct

+ ExecutorType ScheduledJobExecutorType

+ ScheduleID Expr

+ WhichSchedules ScheduleState

+ func (*ShowSchedules) StatementReturnType() StatementReturnType

+ func (*ShowSchedules) StatementTag() string

+ func (*ShowSchedules) StatementType() StatementType

+ func (n *ShowSchedules) Format(ctx *FmtCtx)

+ func (n *ShowSchedules) String() string

+ type ShowSchemas struct

+ Database Name

+ func (*ShowSchemas) StatementReturnType() StatementReturnType

+ func (*ShowSchemas) StatementTag() string

+ func (*ShowSchemas) StatementType() StatementType

+ func (n *ShowSchemas) String() string

+ func (node *ShowSchemas) Format(ctx *FmtCtx)

+ type ShowSequences struct

+ Database Name

+ func (*ShowSequences) StatementReturnType() StatementReturnType

+ func (*ShowSequences) StatementTag() string

+ func (*ShowSequences) StatementType() StatementType

+ func (n *ShowSequences) String() string

+ func (node *ShowSequences) Format(ctx *FmtCtx)

+ type ShowSessions struct

+ All bool

+ Cluster bool

+ func (*ShowSessions) StatementReturnType() StatementReturnType

+ func (*ShowSessions) StatementTag() string

+ func (*ShowSessions) StatementType() StatementType

+ func (n *ShowSessions) String() string

+ func (node *ShowSessions) Format(ctx *FmtCtx)

+ type ShowSurvivalGoal struct

+ DatabaseName Name

+ func (*ShowSurvivalGoal) StatementReturnType() StatementReturnType

+ func (*ShowSurvivalGoal) StatementTag() string

+ func (*ShowSurvivalGoal) StatementType() StatementType

+ func (n *ShowSurvivalGoal) String() string

+ func (node *ShowSurvivalGoal) Format(ctx *FmtCtx)

+ type ShowSyntax struct

+ Statement string

+ func (*ShowSyntax) StatementReturnType() StatementReturnType

+ func (*ShowSyntax) StatementTag() string

+ func (*ShowSyntax) StatementType() StatementType

+ func (n *ShowSyntax) String() string

+ func (node *ShowSyntax) Format(ctx *FmtCtx)

+ type ShowTableStats struct

+ Options KVOptions

+ Table *UnresolvedObjectName

+ UsingJSON bool

+ func (*ShowTableStats) StatementReturnType() StatementReturnType

+ func (*ShowTableStats) StatementTag() string

+ func (*ShowTableStats) StatementType() StatementType

+ func (n *ShowTableStats) String() string

+ func (node *ShowTableStats) Format(ctx *FmtCtx)

+ type ShowTables struct

+ WithComment bool

+ func (*ShowTables) StatementReturnType() StatementReturnType

+ func (*ShowTables) StatementTag() string

+ func (*ShowTables) StatementType() StatementType

+ func (n *ShowTables) String() string

+ func (node *ShowTables) Format(ctx *FmtCtx)

+ type ShowTenant struct

+ TenantSpec *TenantSpec

+ func (*ShowTenant) StatementReturnType() StatementReturnType

+ func (*ShowTenant) StatementTag() string

+ func (*ShowTenant) StatementType() StatementType

+ func (n *ShowTenant) String() string

+ func (node *ShowTenant) Format(ctx *FmtCtx)

+ type ShowTenantClusterSetting struct

+ TenantSpec *TenantSpec

+ func (*ShowTenantClusterSetting) StatementReturnType() StatementReturnType

+ func (*ShowTenantClusterSetting) StatementTag() string

+ func (*ShowTenantClusterSetting) StatementType() StatementType

+ func (n *ShowTenantClusterSetting) String() string

+ func (node *ShowTenantClusterSetting) Format(ctx *FmtCtx)

+ type ShowTenantClusterSettingList struct

+ TenantSpec *TenantSpec

+ func (*ShowTenantClusterSettingList) StatementReturnType() StatementReturnType

+ func (*ShowTenantClusterSettingList) StatementTag() string

+ func (*ShowTenantClusterSettingList) StatementType() StatementType

+ func (n *ShowTenantClusterSettingList) String() string

+ func (node *ShowTenantClusterSettingList) Format(ctx *FmtCtx)

+ type ShowTenantOptions struct

+ WithCapabilities bool

+ WithReplication bool

+ type ShowTraceForSession struct

+ Compact bool

+ TraceType ShowTraceType

+ func (*ShowTraceForSession) StatementReturnType() StatementReturnType

+ func (*ShowTraceForSession) StatementTag() string

+ func (*ShowTraceForSession) StatementType() StatementType

+ func (n *ShowTraceForSession) String() string

+ func (node *ShowTraceForSession) Format(ctx *FmtCtx)

+ type ShowTraceType string

+ const ShowTraceKV

+ const ShowTraceRaw

+ const ShowTraceReplica

+ type ShowTransactionStatus struct

+ func (*ShowTransactionStatus) StatementReturnType() StatementReturnType

+ func (*ShowTransactionStatus) StatementTag() string

+ func (*ShowTransactionStatus) StatementType() StatementType

+ func (n *ShowTransactionStatus) String() string

+ func (node *ShowTransactionStatus) Format(ctx *FmtCtx)

+ type ShowTransactions struct

+ All bool

+ Cluster bool

+ func (*ShowTransactions) StatementReturnType() StatementReturnType

+ func (*ShowTransactions) StatementTag() string

+ func (*ShowTransactions) StatementType() StatementType

+ func (n *ShowTransactions) String() string

+ func (node *ShowTransactions) Format(ctx *FmtCtx)

+ type ShowTransferState struct

+ TransferKey *StrVal

+ func (*ShowTransferState) StatementReturnType() StatementReturnType

+ func (*ShowTransferState) StatementTag() string

+ func (*ShowTransferState) StatementType() StatementType

+ func (n *ShowTransferState) String() string

+ func (node *ShowTransferState) Format(ctx *FmtCtx)

+ type ShowTypes struct

+ func (*ShowTypes) StatementReturnType() StatementReturnType

+ func (*ShowTypes) StatementTag() string

+ func (*ShowTypes) StatementType() StatementType

+ func (n *ShowTypes) String() string

+ func (node *ShowTypes) Format(ctx *FmtCtx)

+ type ShowUsers struct

+ func (*ShowUsers) StatementReturnType() StatementReturnType

+ func (*ShowUsers) StatementTag() string

+ func (*ShowUsers) StatementType() StatementType

+ func (n *ShowUsers) String() string

+ func (node *ShowUsers) Format(ctx *FmtCtx)

+ type ShowVar struct

+ Name string

+ func (*ShowVar) StatementReturnType() StatementReturnType

+ func (*ShowVar) StatementTag() string

+ func (*ShowVar) StatementType() StatementType

+ func (n *ShowVar) String() string

+ func (node *ShowVar) Format(ctx *FmtCtx)

+ type ShowZoneConfig struct

+ func (*ShowZoneConfig) StatementReturnType() StatementReturnType

+ func (*ShowZoneConfig) StatementTag() string

+ func (*ShowZoneConfig) StatementType() StatementType

+ func (n *ShowZoneConfig) String() string

+ func (node *ShowZoneConfig) Format(ctx *FmtCtx)

+ type SimilarToOp struct

+ CaseInsensitive bool

+ Escape rune

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

+ type SizeBatchParam struct

+ Size Expr

+ func (p *SizeBatchParam) Format(ctx *FmtCtx)

+ type SpecializedVectorizedBuiltin int

+ const CrdbInternalRangeStats

+ const SubstringStringIntInt

+ type Split struct

+ ExpireExpr Expr

+ Rows *Select

+ TableOrIndex TableIndexName

+ func (*Split) StatementReturnType() StatementReturnType

+ func (*Split) StatementTag() string

+ func (*Split) StatementType() StatementType

+ func (n *Split) String() string

+ func (node *Split) Format(ctx *FmtCtx)

+ type SqrtDecimalOp struct

+ func (op *SqrtDecimalOp) Eval(ctx context.Context, e OpEvaluator, v Datum) (Datum, error)

+ type SqrtFloatOp struct

+ func (op *SqrtFloatOp) Eval(ctx context.Context, e OpEvaluator, v Datum) (Datum, error)

+ type Statement interface

+ StatementReturnType func() StatementReturnType

+ StatementTag func() string

+ StatementType func() StatementType

+ func MakeExplain(options []string, stmt Statement) (Statement, error)

+ func SimpleStmtVisit(stmt Statement, preFn SimpleVisitFn) (Statement, error)

+ type StatementReturnType int

+ const Ack

+ const CopyIn

+ const CopyOut

+ const DDL

+ const Replication

+ const Rows

+ const RowsAffected

+ const Unknown

+ func (i StatementReturnType) String() string

+ type StatementSource struct

+ Statement Statement

+ func (expr *StatementSource) WalkTableExpr(v Visitor) TableExpr

+ func (node *StatementSource) Format(ctx *FmtCtx)

+ type StatementType int

+ const TypeDCL

+ const TypeDDL

+ const TypeDML

+ const TypeTCL

+ func (i StatementType) String() string

+ type Statements []Statement

+ type StorageParam struct

+ Key Name

+ Value Expr

+ type StorageParams []StorageParam

+ func (o *StorageParams) Format(ctx *FmtCtx)

+ func (o *StorageParams) GetVal(key string) Expr

+ type StrVal struct

+ func NewBytesStrVal(s string) *StrVal

+ func NewStrVal(s string) *StrVal

+ func (expr *StrVal) AvailableTypes() []*types.T

+ func (expr *StrVal) DesirableTypes() []*types.T

+ func (expr *StrVal) Format(ctx *FmtCtx)

+ func (expr *StrVal) RawString() string

+ func (expr *StrVal) ResolveAsType(ctx context.Context, semaCtx *SemaContext, typ *types.T) (TypedExpr, error)

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

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

+ func (node *StrVal) String() string

+ type StringOrPlaceholderOptList []Expr

+ func (node *StringOrPlaceholderOptList) Format(ctx *FmtCtx)

+ type Subquery struct

+ Exists bool

+ Idx int

+ Select SelectStatement

+ func (*Subquery) SubqueryExpr()

+ func (*Subquery) Variable()

+ func (expr *Subquery) TypeCheck(_ context.Context, sc *SemaContext, _ *types.T) (TypedExpr, error)

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

+ func (expr *Subquery) WalkTableExpr(v Visitor) TableExpr

+ func (node *Subquery) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *Subquery) Format(ctx *FmtCtx)

+ func (node *Subquery) ResolvedType() *types.T

+ func (node *Subquery) SetType(t *types.T)

+ func (node *Subquery) String() string

+ type SubqueryExpr interface

+ SubqueryExpr func()

+ type SuperRegion struct

+ Name Name

+ Regions NameList

+ func (node *SuperRegion) Format(ctx *FmtCtx)

+ type SurvivalGoal uint32

+ const SurvivalGoalDefault

+ const SurvivalGoalRegionFailure

+ const SurvivalGoalZoneFailure

+ func (node *SurvivalGoal) Format(ctx *FmtCtx)

+ func (node *SurvivalGoal) TelemetryName() string

+ type TSMatchesQueryVectorOp struct

+ func (op *TSMatchesQueryVectorOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type TSMatchesVectorQueryOp struct

+ func (op *TSMatchesVectorQueryOp) Eval(ctx context.Context, e OpEvaluator, a, b Datum) (Datum, error)

+ type TableAttrs struct

+ SequenceOnly bool

+ TablePatterns TablePatterns

+ type TableDef interface

+ type TableDefs []TableDef

+ func (node *TableDefs) Format(ctx *FmtCtx)

+ type TableExpr interface

+ WalkTableExpr func(Visitor) TableExpr

+ func StripTableParens(expr TableExpr) TableExpr

+ type TableExprs []TableExpr

+ func (node *TableExprs) Format(ctx *FmtCtx)

+ type TableIndexName struct

+ Index UnrestrictedName

+ Table TableName

+ func (n *TableIndexName) Format(ctx *FmtCtx)

+ func (n *TableIndexName) String() string

+ type TableIndexNames []*TableIndexName

+ func (n *TableIndexNames) Format(ctx *FmtCtx)

+ type TableName struct

+ func MakeTableNameFromPrefix(prefix ObjectNamePrefix, object Name) TableName

+ func MakeTableNameWithSchema(db, schema, tbl Name) TableName

+ func MakeUnqualifiedTableName(tbl Name) TableName

+ func NewTableNameWithSchema(db, sc, tbl Name) *TableName

+ func NewUnqualifiedTableName(tbl Name) *TableName

+ func (expr *TableName) WalkTableExpr(_ Visitor) TableExpr

+ func (o *TableName) FQString() string

+ func (o *TableName) Object() string

+ func (o *TableName) String() string

+ func (o *TableName) ToUnresolvedObjectName() *UnresolvedObjectName

+ func (t *TableName) Equals(other *TableName) bool

+ func (t *TableName) Format(ctx *FmtCtx)

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

+ func (t *TableName) Table() string

+ type TableNames []TableName

+ func (ts *TableNames) Format(ctx *FmtCtx)

+ func (ts *TableNames) String() string

+ type TablePattern interface

+ NormalizeTablePattern func() (TablePattern, error)

+ type TablePatterns []TablePattern

+ func (tt *TablePatterns) Format(ctx *FmtCtx)

+ type TableRef struct

+ As AliasClause

+ Columns []ColumnID

+ TableID int64

+ func (expr *TableRef) WalkTableExpr(_ Visitor) TableExpr

+ func (n *TableRef) Format(ctx *FmtCtx)

+ func (n *TableRef) String() string

+ type TenantCapability struct

+ Name string

+ Value Expr

+ type TenantID struct

+ ID uint64

+ Specified bool

+ func (t *TenantID) Format(ctx *FmtCtx)

+ func (t *TenantID) IsSet() bool

+ type TenantReplicationOptions struct

+ ResumeTimestamp Expr

+ Retention Expr

+ func (o *TenantReplicationOptions) CombineWith(other *TenantReplicationOptions) error

+ func (o *TenantReplicationOptions) Format(ctx *FmtCtx)

+ func (o TenantReplicationOptions) IsDefault() bool

+ type TenantServiceCmd int8

+ const TenantStartServiceExternal

+ const TenantStartServiceShared

+ const TenantStopService

+ type TenantSpec struct

+ All bool

+ Expr Expr

+ IsName bool

+ func (n *TenantSpec) Format(ctx *FmtCtx)

+ func (n *TenantSpec) String() string

+ type TestingMapTypeResolver struct

+ func (dtr *TestingMapTypeResolver) ResolveType(_ context.Context, name *UnresolvedObjectName) (*types.T, error)

+ func (dtr *TestingMapTypeResolver) ResolveTypeByOID(context.Context, oid.Oid) (*types.T, error)

+ type TransactionModes struct

+ AsOf AsOfClause

+ Deferrable DeferrableMode

+ Isolation IsolationLevel

+ ReadWriteMode ReadWriteMode

+ UserPriority UserPriority

+ func (node *TransactionModes) Format(ctx *FmtCtx)

+ func (node *TransactionModes) Merge(other TransactionModes) error

+ type Truncate struct

+ DropBehavior DropBehavior

+ Tables TableNames

+ func (*Truncate) StatementReturnType() StatementReturnType

+ func (*Truncate) StatementTag() string

+ func (*Truncate) StatementType() StatementType

+ func (n *Truncate) String() string

+ func (node *Truncate) Format(ctx *FmtCtx)

+ type Tuple struct

+ Exprs Exprs

+ Labels []string

+ Row bool

+ func NewTypedTuple(typ *types.T, typedExprs Exprs) *Tuple

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

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

+ func (node *Tuple) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *Tuple) Format(ctx *FmtCtx)

+ func (node *Tuple) ResolvedType() *types.T

+ func (node *Tuple) String() string

+ type TupleStar struct

+ Expr Expr

+ func (expr *TupleStar) ResolvedType() *types.T

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

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

+ func (node *TupleStar) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *TupleStar) Format(ctx *FmtCtx)

+ func (node *TupleStar) NormalizeVarName() (VarName, error)

+ func (node *TupleStar) String() string

+ type TypeCollectorVisitor struct

+ OIDs map[oid.Oid]struct{}

+ func (v *TypeCollectorVisitor) VisitPost(e Expr) Expr

+ func (v *TypeCollectorVisitor) VisitPre(expr Expr) (bool, Expr)

+ type TypeList interface

+ GetAt func(i int) *types.T

+ Length func() int

+ Match func(types []*types.T) bool

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

+ MatchAtIdentical func(typ *types.T, i int) bool

+ MatchIdentical func(types []*types.T) bool

+ MatchLen func(l int) bool

+ String func() string

+ Types func() []*types.T

+ type TypeName struct

+ func MakeQualifiedTypeName(db, schema, typ string) TypeName

+ func MakeSchemaQualifiedTypeName(schema, typ string) TypeName

+ func MakeTypeNameWithPrefix(prefix ObjectNamePrefix, typ string) TypeName

+ func MakeUnqualifiedTypeName(typ string) TypeName

+ func NewQualifiedTypeName(db, schema, typ string) *TypeName

+ func NewUnqualifiedTypeName(typ string) *TypeName

+ func (o *TypeName) FQString() string

+ func (o *TypeName) Object() string

+ func (o *TypeName) String() string

+ func (o *TypeName) ToUnresolvedObjectName() *UnresolvedObjectName

+ func (t *TypeName) Format(ctx *FmtCtx)

+ func (t *TypeName) SQLString() string

+ func (t *TypeName) Type() string

+ type TypeReferenceResolver interface

+ ResolveType func(ctx context.Context, name *UnresolvedObjectName) (*types.T, error)

+ ResolveTypeByOID func(ctx context.Context, oid oid.Oid) (*types.T, error)

+ func MakeTestingMapTypeResolver(typeMap map[string]*types.T) TypeReferenceResolver

+ type TypedDummy struct

+ Typ *types.T

+ func (node *TypedDummy) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *TypedDummy) Format(ctx *FmtCtx)

+ func (node *TypedDummy) ResolvedType() *types.T

+ func (node *TypedDummy) String() string

+ func (node *TypedDummy) TypeCheck(context.Context, *SemaContext, *types.T) (TypedExpr, error)

+ func (node *TypedDummy) Walk(Visitor) Expr

+ type TypedExpr interface

+ Eval func(context.Context, ExprEvaluator) (Datum, error)

+ ResolvedType func() *types.T

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

+ func TypeCheckAndRequire(ctx context.Context, expr Expr, semaCtx *SemaContext, required *types.T, ...) (TypedExpr, error)

+ type TypedExprs []TypedExpr

+ func (node *TypedExprs) Format(ctx *FmtCtx)

+ func (node *TypedExprs) String() string

+ type UDFDisallowanceVisitor struct

+ FoundUDF bool

+ func (v *UDFDisallowanceVisitor) VisitPost(expr Expr) (newNode Expr)

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

+ type UnaryEvalOp interface

+ Eval func(context.Context, OpEvaluator, Datum) (Datum, error)

+ type UnaryExpr struct

+ Expr Expr

+ Operator UnaryOperator

+ func NewTypedUnaryExpr(op UnaryOperator, expr TypedExpr, typ *types.T) *UnaryExpr

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

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

+ func (node *UnaryExpr) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (node *UnaryExpr) Format(ctx *FmtCtx)

+ func (node *UnaryExpr) GetOp() *UnaryOp

+ func (node *UnaryExpr) String() string

+ func (node *UnaryExpr) TypedInnerExpr() TypedExpr

+ func (ta UnaryExpr) ResolvedType() *types.T

+ type UnaryMinusDecimalOp struct

+ func (op *UnaryMinusDecimalOp) Eval(ctx context.Context, e OpEvaluator, v Datum) (Datum, error)

+ type UnaryMinusFloatOp struct

+ func (op *UnaryMinusFloatOp) Eval(ctx context.Context, e OpEvaluator, v Datum) (Datum, error)

+ type UnaryMinusIntOp struct

+ func (op *UnaryMinusIntOp) Eval(ctx context.Context, e OpEvaluator, v Datum) (Datum, error)

+ type UnaryMinusIntervalOp struct

+ func (op *UnaryMinusIntervalOp) Eval(ctx context.Context, e OpEvaluator, v Datum) (Datum, error)

+ type UnaryNoop struct

+ func (v *UnaryNoop) Eval(ctx context.Context, evaluator OpEvaluator, d Datum) (Datum, error)

+ type UnaryOp struct

+ EvalOp UnaryEvalOp

+ OnTypeCheck func()

+ ReturnType *types.T

+ Typ *types.T

+ Volatility volatility.V

+ type UnaryOpEvaluator interface

+ EvalCbrtDecimalOp func(context.Context, *CbrtDecimalOp, Datum) (Datum, error)

+ EvalCbrtFloatOp func(context.Context, *CbrtFloatOp, Datum) (Datum, error)

+ EvalComplementINetOp func(context.Context, *ComplementINetOp, Datum) (Datum, error)

+ EvalComplementIntOp func(context.Context, *ComplementIntOp, Datum) (Datum, error)

+ EvalComplementVarBitOp func(context.Context, *ComplementVarBitOp, Datum) (Datum, error)

+ EvalSqrtDecimalOp func(context.Context, *SqrtDecimalOp, Datum) (Datum, error)

+ EvalSqrtFloatOp func(context.Context, *SqrtFloatOp, Datum) (Datum, error)

+ EvalUnaryMinusDecimalOp func(context.Context, *UnaryMinusDecimalOp, Datum) (Datum, error)

+ EvalUnaryMinusFloatOp func(context.Context, *UnaryMinusFloatOp, Datum) (Datum, error)

+ EvalUnaryMinusIntOp func(context.Context, *UnaryMinusIntOp, Datum) (Datum, error)

+ EvalUnaryMinusIntervalOp func(context.Context, *UnaryMinusIntervalOp, Datum) (Datum, error)

+ type UnaryOpOverloads struct

+ func (u *UnaryOpOverloads) ForEachUnaryOp(f func(op *UnaryOp) error) error

+ type UnaryOperator struct

+ IsExplicitOperator bool

+ Symbol UnaryOperatorSymbol

+ func MakeUnaryOperator(symbol UnaryOperatorSymbol) UnaryOperator

+ func (UnaryOperator) Operator()

+ func (o UnaryOperator) String() string

+ type UnaryOperatorSymbol uint8

+ const NumUnaryOperatorSymbols

+ const UnaryCbrt

+ const UnaryComplement

+ const UnaryMinus

+ const UnaryPlus

+ const UnarySqrt

+ func (i UnaryOperatorSymbol) String() string

+ type UnionClause struct

+ All bool

+ Left *Select

+ Right *Select

+ Type UnionType

+ func (*UnionClause) StatementReturnType() StatementReturnType

+ func (*UnionClause) StatementTag() string

+ func (*UnionClause) StatementType() StatementType

+ func (n *UnionClause) String() string

+ func (node *UnionClause) Format(ctx *FmtCtx)

+ type UnionType int

+ const ExceptOp

+ const IntersectOp

+ const UnionOp

+ func (i UnionType) String() string

+ type UniqueConstraint struct

+ WithoutIndex bool

+ type UniqueConstraintTableDef struct

+ IfNotExists bool

+ PrimaryKey bool

+ WithoutIndex bool

+ func (node *UniqueConstraintTableDef) Format(ctx *FmtCtx)

+ func (node *UniqueConstraintTableDef) SetIfNotExists()

+ func (node *UniqueConstraintTableDef) SetName(name Name)

+ type Unlisten struct

+ ChannelName *UnresolvedObjectName

+ Star bool

+ func (*Unlisten) StatementReturnType() StatementReturnType

+ func (*Unlisten) StatementTag() string

+ func (*Unlisten) StatementType() StatementType

+ func (node *Unlisten) Format(ctx *FmtCtx)

+ func (node *Unlisten) String() string

+ type UnqualifiedStar struct

+ func (UnqualifiedStar) Format(ctx *FmtCtx)

+ func (UnqualifiedStar) ResolvedType() *types.T

+ func (UnqualifiedStar) Variable()

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

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

+ func (node UnqualifiedStar) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

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

+ func (u UnqualifiedStar) String() string

+ type UnresolvedFunctionName struct

+ func MakeUnresolvedFunctionName(u *UnresolvedName) UnresolvedFunctionName

+ func (u UnresolvedFunctionName) UnresolvedName() *UnresolvedName

+ type UnresolvedName struct

+ NumParts int

+ Parts NameParts

+ Star bool

+ func MakeUnresolvedName(args ...string) UnresolvedName

+ func NewUnresolvedName(args ...string) *UnresolvedName

+ func (*UnresolvedName) ResolvedType() *types.T

+ func (*UnresolvedName) Variable()

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

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

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

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

+ func (node *UnresolvedName) Eval(ctx context.Context, v ExprEvaluator) (Datum, error)

+ func (u *UnresolvedName) Format(ctx *FmtCtx)

+ func (u *UnresolvedName) String() string

+ func (u *UnresolvedName) ToRoutineName() (RoutineName, error)

+ func (u *UnresolvedName) ToUnresolvedObjectName(idx AnnotationIdx) (UnresolvedObjectName, error)

+ type UnresolvedObjectName struct

+ NumParts int

+ Parts [3]string

+ func MakeUnresolvedObjectName(numParts int, parts [3]string, annotationIdx AnnotationIdx) (UnresolvedObjectName, error)

+ func NewUnresolvedObjectName(numParts int, parts [3]string, annotationIdx AnnotationIdx) (*UnresolvedObjectName, error)

+ func (expr *UnresolvedObjectName) WalkTableExpr(_ Visitor) TableExpr

+ func (name *UnresolvedObjectName) SQLString() string

+ func (u *UnresolvedObjectName) Catalog() string

+ func (u *UnresolvedObjectName) Format(ctx *FmtCtx)

+ func (u *UnresolvedObjectName) HasExplicitCatalog() bool

+ func (u *UnresolvedObjectName) HasExplicitSchema() bool

+ func (u *UnresolvedObjectName) Object() string

+ func (u *UnresolvedObjectName) Resolved(ann *Annotations) ObjectName

+ func (u *UnresolvedObjectName) Schema() string

+ func (u *UnresolvedObjectName) String() string

+ func (u *UnresolvedObjectName) ToRoutineName() RoutineName

+ func (u *UnresolvedObjectName) ToTableName() TableName

+ func (u *UnresolvedObjectName) ToUnresolvedName() *UnresolvedName

+ type UnresolvedProcedureName struct

+ func MakeUnresolvedProcedureName(u *UnresolvedName) UnresolvedProcedureName

+ func (u UnresolvedProcedureName) UnresolvedName() *UnresolvedName

+ type UnresolvedRoutineName interface

+ UnresolvedName func() *UnresolvedName

+ type UnrestrictedName string

+ func (node *UnrestrictedName) String() string

+ func (u *UnrestrictedName) Format(ctx *FmtCtx)

+ type UnspecifiedObjectName struct

+ func (o *UnspecifiedObjectName) FQString() string

+ func (o *UnspecifiedObjectName) Format(ctx *FmtCtx)

+ func (o *UnspecifiedObjectName) Object() string

+ func (o *UnspecifiedObjectName) String() string

+ func (o *UnspecifiedObjectName) ToUnresolvedObjectName() *UnresolvedObjectName

+ type Unsplit struct

+ All bool

+ Rows *Select

+ TableOrIndex TableIndexName

+ func (*Unsplit) StatementReturnType() StatementReturnType

+ func (*Unsplit) StatementTag() string

+ func (*Unsplit) StatementType() StatementType

+ func (n *Unsplit) String() string

+ func (node *Unsplit) Format(ctx *FmtCtx)

+ type UnsupportedError struct

+ Err error

+ FeatureName string

+ func (u *UnsupportedError) Cause() error

+ func (u *UnsupportedError) Error() string

+ func (u *UnsupportedError) Unwrap() error

+ type UnsupportedTypeChecker interface

+ CheckType func(ctx context.Context, typ *types.T) error

+ type Update struct

+ Exprs UpdateExprs

+ From TableExprs

+ Limit *Limit

+ OrderBy OrderBy

+ Returning ReturningClause

+ Table TableExpr

+ Where *Where

+ With *With

+ func (*Update) StatementTag() string

+ func (*Update) StatementType() StatementType

+ func (n *Update) StatementReturnType() StatementReturnType

+ func (n *Update) String() string

+ func (node *Update) Format(ctx *FmtCtx)

+ type UpdateExpr struct

+ Expr Expr

+ Names NameList

+ Tuple bool

+ func (node *UpdateExpr) Format(ctx *FmtCtx)

+ type UpdateExprs []*UpdateExpr

+ func (node *UpdateExprs) Format(ctx *FmtCtx)

+ type UserPriority int

+ const High

+ const Low

+ const Normal

+ const UnspecifiedUserPriority

+ func UserPriorityFromString(val string) (_ UserPriority, ok bool)

+ func (up UserPriority) String() string

+ type UsingJoinCond struct

+ Cols NameList

+ func (node *UsingJoinCond) Format(ctx *FmtCtx)

+ type ValidationBehavior int

+ const ValidationDefault

+ const ValidationSkip

+ type ValueHandler interface

+ Bool func(b bool)

+ Bytes func(b []byte)

+ Date func(d pgdate.Date)

+ Datum func(d Datum)

+ Decimal func() *apd.Decimal

+ Duration func(d duration.Duration)

+ Float func(f float64)

+ Int func(i int64)

+ Int16 func(i int16)

+ Int32 func(i int32)

+ JSON func(j json.JSON)

+ Len func() int

+ Null func()

+ Reset func()

+ String func(s string)

+ TimestampTZ func(t time.Time)

+ type ValuesClause struct

+ Rows []Exprs

+ func (*ValuesClause) StatementReturnType() StatementReturnType

+ func (*ValuesClause) StatementTag() string

+ func (*ValuesClause) StatementType() StatementType

+ func (n *ValuesClause) String() string

+ func (node *ValuesClause) Format(ctx *FmtCtx)

+ type VarName interface

+ NormalizeVarName func() (VarName, error)

+ func StarExpr() VarName

+ type VariableExpr interface

+ Variable func()

+ type VariadicType struct

+ FixedTypes []*types.T

+ VarType *types.T

+ func (VariadicType) MatchAtIdentical(typ *types.T, i int) bool

+ func (VariadicType) MatchIdentical(types []*types.T) bool

+ func (v VariadicType) GetAt(i int) *types.T

+ func (v VariadicType) Length() int

+ func (v VariadicType) Match(types []*types.T) bool

+ func (v VariadicType) MatchAt(typ *types.T, i int) bool

+ func (v VariadicType) MatchLen(l int) bool

+ func (v VariadicType) String() string

+ func (v VariadicType) Types() []*types.T

+ type VectorRows struct

+ Batch coldata.Batch

+ func (r VectorRows) Get(i, j int) Expr

+ func (r VectorRows) NumCols() int

+ func (r VectorRows) NumRows() int

+ type Visitor interface

+ VisitPost func(expr Expr) (newNode Expr)

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

+ type When struct

+ Cond Expr

+ Val Expr

+ func (node *When) Format(ctx *FmtCtx)

+ type Where struct

+ Expr Expr

+ Type string

+ func NewWhere(typ string, expr Expr) *Where

+ func (node *Where) Format(ctx *FmtCtx)

+ type Window []*WindowDef

+ func (node *Window) Format(ctx *FmtCtx)

+ type WindowDef struct

+ Frame *WindowFrame

+ Name Name

+ OrderBy OrderBy

+ Partitions Exprs

+ RefName Name

+ func OverrideWindowDef(base *WindowDef, override WindowDef) (WindowDef, error)

+ func (node *WindowDef) Format(ctx *FmtCtx)

+ type WindowFrame struct

+ Bounds WindowFrameBounds

+ Exclusion treewindow.WindowFrameExclusion

+ Mode treewindow.WindowFrameMode

+ func (f *WindowFrame) DefaultFrameExclusion() bool

+ func (f *WindowFrame) Format(ctx *FmtCtx)

+ func (f *WindowFrame) IsDefaultFrame() bool

+ type WindowFrameBound struct

+ BoundType treewindow.WindowFrameBoundType

+ OffsetExpr Expr

+ func (node *WindowFrameBound) Format(ctx *FmtCtx)

+ func (node *WindowFrameBound) HasOffset() bool

+ type WindowFrameBounds struct

+ EndBound *WindowFrameBound

+ StartBound *WindowFrameBound

+ func (node *WindowFrameBounds) HasOffset() bool

+ type WindowOverload interface

+ Window func()

+ type With struct

+ CTEList []*CTE

+ Recursive bool

+ func (node *With) Format(ctx *FmtCtx)

+ type ZoneConfigSettings struct

+ Options KVOptions

+ SetDefault bool

+ YAMLConfig Expr

+ func (node *ZoneConfigSettings) Format(ctx *FmtCtx)

+ type ZoneSpecifier struct

+ Database Name

+ NamedZone UnrestrictedName

+ Partition Name

+ TableOrIndex TableIndexName

+ func (node *ZoneSpecifier) Format(ctx *FmtCtx)

+ func (node *ZoneSpecifier) String() string

+ func (node ZoneSpecifier) TargetsIndex() bool

+ func (node ZoneSpecifier) TargetsPartition() bool

+ func (node ZoneSpecifier) TargetsTable() bool

+ func (node ZoneSpecifier) TelemetryName() string

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL