tree

package

Go to main page

Versions in this module

v0

v0.14.1

Nov 13, 2024

Changes in this version

type ExplainFlag

+ const ExplainFlagBuffers

+ const ExplainFlagCosts

+ const ExplainFlagFormat

+ const ExplainFlagSettings

+ const ExplainFlagSummary

+ const ExplainFlagTiming

+ const ExplainFlagWAL

v0.14.0

Nov 8, 2024

Changes in this version

+ type DomainColumn struct

+ Typ ResolvableTypeReference

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

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

+ func (d DomainColumn) String() string

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

+ func (d DomainColumn) Walk(_ Visitor) Expr

v0.13.0

Oct 17, 2024

Changes in this version

type AliasedTableExpr

+ AsOf *AsOfClause

type CopyOptions

+ Delimiter string

type Explain

+ AsOf *AsOfClause

+ TableName *UnresolvedObjectName

type SetVar

+ Namespace string

v0.12.0

Sep 30, 2024

Changes in this version

type CopyFormat

+ const CopyFormatCsv

type CopyFrom

+ File string

type CopyOptions

+ Header bool

type UnresolvedName

+ func (u *UnresolvedName) GetUnresolvedObjectName() *UnresolvedObjectName

v0.11.1

Aug 21, 2024

v0.11.0

Aug 12, 2024

v0.10.0

Jul 2, 2024

v0.9.0

Jun 11, 2024

v0.8.0

Jun 4, 2024

v0.7.5

May 20, 2024

v0.7.4

May 14, 2024

v0.7.1

May 13, 2024

v0.7.0

May 13, 2024

Changes in this version

type ViewOption

+ CheckOpt string

+ Security bool

v0.6.0

Apr 16, 2024

Changes in this version

type AndExpr

+ func (ta AndExpr) HasResolvedType() bool

type Array

+ func (ta Array) HasResolvedType() bool

type ArrayFlatten

+ func (ta ArrayFlatten) HasResolvedType() bool

type BinaryExpr

+ func (ta BinaryExpr) HasResolvedType() bool

type CaseExpr

+ func (ta CaseExpr) HasResolvedType() bool

type CastExpr

+ func (ta CastExpr) HasResolvedType() bool

type CoalesceExpr

+ func (ta CoalesceExpr) HasResolvedType() bool

type CollateExpr

+ func (ta CollateExpr) HasResolvedType() bool

type ColumnAccessExpr

+ func (ta ColumnAccessExpr) HasResolvedType() bool

+ type Comment struct

+ Comment *string

+ Object CommentObject

+ func (*Comment) StatementTag() string

+ func (*Comment) StatementType() StatementType

+ func (n *Comment) String() string

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

+ type CommentObject interface

+ type CommentOnAccessMethod struct

+ Name *UnresolvedObjectName

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

+ type CommentOnAggregate struct

+ AggSig *AggregateSignature

+ Name *UnresolvedObjectName

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

+ type CommentOnCast struct

+ Source ResolvableTypeReference

+ Target ResolvableTypeReference

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

+ type CommentOnCollation struct

+ Name string

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

+ type CommentOnConstraintOnDomain struct

+ Constraint Name

+ Domain *UnresolvedObjectName

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

+ type CommentOnConstraintOnTable struct

+ Constraint Name

+ Table *UnresolvedObjectName

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

+ type CommentOnConversion struct

+ Name Name

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

+ type CommentOnDomain struct

+ Name *UnresolvedObjectName

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

+ type CommentOnEventTrigger struct

+ Name Name

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

+ type CommentOnForeignDataWrapper struct

+ Name Name

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

+ type CommentOnForeignTable struct

+ Name Name

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

+ type CommentOnFunction struct

+ Args RoutineArgs

+ Name *UnresolvedObjectName

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

+ type CommentOnLanguage struct

+ Name Name

+ Procedural bool

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

+ type CommentOnLargeObject struct

+ Oid Expr

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

+ type CommentOnMaterializedView struct

+ Name *UnresolvedObjectName

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

+ type CommentOnOperator struct

+ Left ResolvableTypeReference

+ Op Operator

+ Right ResolvableTypeReference

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

+ type CommentOnOperatorClass struct

+ IdxMethod string

+ Name Name

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

+ type CommentOnOperatorFamily struct

+ IdxMethod string

+ Name Name

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

+ type CommentOnPolicy struct

+ Policy Name

+ Table *UnresolvedObjectName

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

+ type CommentOnProcedure struct

+ Args RoutineArgs

+ Name *UnresolvedObjectName

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

+ type CommentOnPublication struct

+ Name Name

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

+ type CommentOnRole struct

+ Name string

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

+ type CommentOnRoutine struct

+ Args RoutineArgs

+ Name *UnresolvedObjectName

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

+ type CommentOnRule struct

+ Rule Name

+ Table *UnresolvedObjectName

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

+ type CommentOnSchema struct

+ Name string

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

+ type CommentOnSequence struct

+ Name *UnresolvedObjectName

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

+ type CommentOnServer struct

+ Name Name

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

+ type CommentOnStatistics struct

+ Name Name

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

+ type CommentOnSubscription struct

+ Name Name

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

type CommentOnTable

+ Name *UnresolvedObjectName

+ type CommentOnTablespace struct

+ Name Name

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

+ type CommentOnTextSearchConfiguration struct

+ Name Name

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

+ type CommentOnTextSearchDictionary struct

+ Name Name

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

+ type CommentOnTextSearchParser struct

+ Name Name

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

+ type CommentOnTextSearchTemplate struct

+ Name Name

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

+ type CommentOnTransformFor struct

+ Language Name

+ Type ResolvableTypeReference

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

+ type CommentOnTrigger struct

+ Table *UnresolvedObjectName

+ Trigger Name

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

+ type CommentOnType struct

+ Name *UnresolvedObjectName

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

+ type CommentOnView struct

+ Name *UnresolvedObjectName

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

type ComparisonExpr

+ func (ta ComparisonExpr) HasResolvedType() bool

type ComparisonOperator

+ const TextSearchMatch

type CreateFunction

+ SetOf bool

type FuncExpr

+ func (ta FuncExpr) HasResolvedType() bool

type IfErrExpr

+ func (ta IfErrExpr) HasResolvedType() bool

type IfExpr

+ func (ta IfExpr) HasResolvedType() bool

type IndexedVar

+ func (ta IndexedVar) HasResolvedType() bool

type IndirectionExpr

+ func (ta IndirectionExpr) HasResolvedType() bool

type IsNotNullExpr

+ func (ta IsNotNullExpr) HasResolvedType() bool

type IsNullExpr

+ func (ta IsNullExpr) HasResolvedType() bool

type IsOfTypeExpr

+ func (ta IsOfTypeExpr) HasResolvedType() bool

type NotExpr

+ func (ta NotExpr) HasResolvedType() bool

type NullIfExpr

+ func (ta NullIfExpr) HasResolvedType() bool

type OrExpr

+ func (ta OrExpr) HasResolvedType() bool

type ParenExpr

+ func (ta ParenExpr) HasResolvedType() bool

type Placeholder

+ func (ta Placeholder) HasResolvedType() bool

type RangeCond

+ func (ta RangeCond) HasResolvedType() bool

+ type RoutineArgMode int8

+ const RoutineArgModeIn

+ const RoutineArgModeInout

+ const RoutineArgModeOut

+ const RoutineArgModeVariadic

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

type Subquery

+ func (ta Subquery) HasResolvedType() bool

type UnaryExpr

+ func (ta UnaryExpr) HasResolvedType() bool

type UnaryOperator

+ const UnaryAbsolute

v0.5.0

Mar 28, 2024

Changes in this version

+ const SeqOptRestart

+ type AggregateToDrop struct

+ AggSig *AggregateSignature

+ Name Name

+ type AlterAttributeAction struct

+ Action string

+ ColName Name

+ Collate string

+ DropBehavior DropBehavior

+ IfExists bool

+ TypeName ResolvableTypeReference

+ type AlterColComputed struct

+ ByDefault bool

+ IsRestart bool

+ Options SequenceOptions

+ Restart Expr

+ type AlterDomain struct

+ Cmd AlterDomainCmd

+ Name *UnresolvedObjectName

+ func (*AlterDomain) StatementTag() string

+ func (*AlterDomain) StatementType() StatementType

+ func (n *AlterDomain) String() string

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

+ type AlterDomainCmd interface

+ type AlterDomainConstraint struct

+ Action AlterDomainConstraintAction

+ Constraint DomainConstraint

+ ConstraintName Name

+ DropBehavior DropBehavior

+ IfExists bool

+ NewName Name

+ NotValid bool

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

+ type AlterDomainConstraintAction int

+ const AlterDomainAddConstraint

+ const AlterDomainDropConstraint

+ const AlterDomainRenameConstraint

+ const AlterDomainValidateConstraint

+ type AlterDomainOwner struct

+ Owner string

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

+ type AlterDomainRename struct

+ NewName string

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

+ type AlterDomainSetDrop struct

+ Default Expr

+ IsSet bool

+ NotNull bool

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

+ type AlterDomainSetSchema struct

+ Schema string

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

+ type AlterFunction struct

+ Args RoutineArgs

+ Extension string

+ Name *UnresolvedObjectName

+ No bool

+ Options []RoutineOption

+ Owner string

+ Rename *UnresolvedObjectName

+ Restrict bool

+ Schema string

+ func (*AlterFunction) StatementTag() string

+ func (*AlterFunction) StatementType() StatementType

+ func (n *AlterFunction) String() string

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

type AlterIndex

+ Cmd AlterIndexCmd

+ type AlterIndexAllInTablespace struct

+ Name Name

+ NoWait bool

+ OwnedBy []string

+ Tablespace string

+ func (*AlterIndexAllInTablespace) StatementTag() string

+ func (*AlterIndexAllInTablespace) StatementType() StatementType

+ func (n *AlterIndexAllInTablespace) String() string

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

+ type AlterIndexAttachPartition struct

+ Index UnrestrictedName

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

+ type AlterIndexExtension struct

+ Extension string

+ No bool

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

+ type AlterIndexSetStatistics struct

+ ColumnIdx Expr

+ Stats Expr

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

+ type AlterIndexSetStorage struct

+ IsReset bool

+ Params StorageParams

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

+ type AlterIndexSetTablespace struct

+ Tablespace string

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

+ type AlterLanguage struct

+ Name Name

+ NewName Name

+ Owner string

+ Procedural bool

+ func (*AlterLanguage) StatementTag() string

+ func (*AlterLanguage) StatementType() StatementType

+ func (n *AlterLanguage) String() string

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

+ type AlterMaterializedView struct

+ Cmds AlterTableCmds

+ Extension string

+ IfExists bool

+ Name *UnresolvedObjectName

+ No bool

+ func (*AlterMaterializedView) StatementTag() string

+ func (*AlterMaterializedView) StatementType() StatementType

+ func (n *AlterMaterializedView) String() string

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

+ type AlterProcedure struct

+ Args RoutineArgs

+ Extension string

+ Name *UnresolvedObjectName

+ No bool

+ Options []RoutineOption

+ Owner string

+ Rename *UnresolvedObjectName

+ Restrict bool

+ Schema string

+ func (*AlterProcedure) StatementTag() string

+ func (*AlterProcedure) StatementType() StatementType

+ func (n *AlterProcedure) String() string

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

type AlterSequence

+ Logged bool

+ Owner string

+ SetLog bool

+ type AlterTableAllInTablespace struct

+ IsMaterialized bool

+ Name Name

+ NoWait bool

+ OwnedBy []string

+ Tablespace string

+ func (*AlterTableAllInTablespace) StatementTag() string

+ func (*AlterTableAllInTablespace) StatementType() StatementType

+ func (n *AlterTableAllInTablespace) String() string

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

+ type AlterTableAlterConstraint struct

+ Constraint Name

+ Deferrable DeferrableMode

+ Initially InitiallyMode

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

+ type AlterTableCluster struct

+ OnIndex Name

+ Without bool

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

+ type AlterTableColSetStorage struct

+ Column Name

+ Type StorageType

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

+ func (node *AlterTableColSetStorage) GetColumn() Name

+ type AlterTableComputed struct

+ AddDefs ColumnQualification

+ Column Name

+ Defs []AlterColComputed

+ IsAdd bool

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

+ func (node *AlterTableComputed) GetColumn() Name

+ type AlterTableConstraintUsingIndex struct

+ Constraint Name

+ Deferrable DeferrableMode

+ Index Name

+ Initially InitiallyMode

+ IsUnique bool

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

+ type AlterTableDropExprIden struct

+ Column Name

+ IfExists bool

+ IsIdentity bool

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

+ func (node *AlterTableDropExprIden) GetColumn() Name

+ type AlterTableInherit struct

+ Inherit bool

+ Table TableName

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

+ type AlterTableOfType struct

+ NotOf bool

+ Type ResolvableTypeReference

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

+ type AlterTablePartition struct

+ DetachType DetachPartition

+ IfExists bool

+ IsDetach bool

+ Name *UnresolvedObjectName

+ Partition Name

+ Spec PartitionBoundSpec

+ func (*AlterTablePartition) StatementTag() string

+ func (*AlterTablePartition) StatementType() StatementType

+ func (n *AlterTablePartition) String() string

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

+ type AlterTableReplicaIdentity struct

+ Index Name

+ Type ReplicaIdentity

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

+ type AlterTableRowLevelSecurity struct

+ Type RowLevelSecurity

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

+ type AlterTableRule struct

+ Disable bool

+ IsAlways bool

+ IsReplica bool

+ Rule string

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

+ type AlterTableSetAccessMethod struct

+ Method string

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

+ type AlterTableSetAttribution struct

+ Column Name

+ Params StorageParams

+ Reset bool

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

+ func (node *AlterTableSetAttribution) GetColumn() Name

+ type AlterTableSetCompression struct

+ Column Name

+ Compression string

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

+ func (node *AlterTableSetCompression) GetColumn() Name

+ type AlterTableSetLog struct

+ Logged bool

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

+ type AlterTableSetStatistics struct

+ Column Name

+ Num Expr

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

+ func (node *AlterTableSetStatistics) GetColumn() Name

+ type AlterTableSetStorage struct

+ IsReset bool

+ Params StorageParams

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

+ type AlterTableSetTablespace struct

+ Tablespace string

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

+ type AlterTableTrigger struct

+ Disable bool

+ IsAlways bool

+ IsReplica bool

+ Trigger string

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

+ type AlterTrigger struct

+ Extension string

+ Name Name

+ NewName Name

+ No bool

+ OnTable TableName

+ func (*AlterTrigger) StatementTag() string

+ func (*AlterTrigger) StatementType() StatementType

+ func (n *AlterTrigger) String() string

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

+ type AlterTypeAlterAttribute struct

+ Actions []AlterAttributeAction

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

+ type AlterTypeRenameAttribute struct

+ ColName Name

+ DropBehavior DropBehavior

+ NewColName Name

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

+ type AlterTypeSetProperty struct

+ Properties BaseTypeOptions

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

+ type AlterView struct

+ Cmd AlterViewCmd

+ IfExists bool

+ Name *UnresolvedObjectName

+ func (*AlterView) StatementTag() string

+ func (*AlterView) StatementType() StatementType

+ func (n *AlterView) String() string

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

+ type AlterViewCmd interface

+ type AlterViewOwnerTo struct

+ Owner string

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

+ type AlterViewRenameColumn struct

+ Column Name

+ NewName Name

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

+ type AlterViewRenameTo struct

+ Rename *UnresolvedObjectName

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

+ type AlterViewSetDefault struct

+ Column Name

+ Default Expr

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

+ type AlterViewSetOption struct

+ Params ViewOptions

+ Reset bool

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

+ type AlterViewSetSchema struct

+ Schema string

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

+ type BaseType struct

+ Input string

+ Options BaseTypeOptions

+ Output string

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

+ type BaseTypeOption struct

+ BoolVal bool

+ Default Expr

+ InternalLength int64

+ Option BaseTypeOptionType

+ StrVal string

+ TypeVal ResolvableTypeReference

+ type BaseTypeOptionType int

+ const BaseTypeAlignment

+ const BaseTypeAnalyze

+ const BaseTypeCategory

+ const BaseTypeCollatable

+ const BaseTypeDefault

+ const BaseTypeDelimiter

+ const BaseTypeElement

+ const BaseTypeInternalLength

+ const BaseTypeLikeType

+ const BaseTypePassedByValue

+ const BaseTypePreferred

+ const BaseTypeReceive

+ const BaseTypeSend

+ const BaseTypeStorage

+ const BaseTypeSubscript

+ const BaseTypeTypModIn

+ const BaseTypeTypeModOut

+ type BaseTypeOptions []BaseTypeOption

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

type CheckConstraintTableDef

+ NoInherit bool

type ColumnCheckConstraint

+ NoInherit bool

type ColumnComputedDef

+ ByDefault bool

+ Options SequenceOptions

type ColumnTableDef

+ Collation string

+ Compression string

+ UniqueDeferrable DeferrableMode

+ UniqueInitially InitiallyMode

type ColumnTableDefCheckExpr

+ NoInherit bool

+ type CompositeType struct

+ Types []CompositeTypeElem

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

+ type CompositeTypeElem struct

+ AttrName string

+ Collate string

+ Type ResolvableTypeReference

+ type CreateAggOption struct

+ BoolVal bool

+ CondVal Expr

+ FinalFuncModify FinalFuncModifyType

+ IntVal Expr

+ Option CreateOptionType

+ Parallel Parallel

+ SortOp Operator

+ StrVal string

+ TypeVal ResolvableTypeReference

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

+ type CreateAggOptions []CreateAggOption

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

+ type CreateAggregate struct

+ AggOptions CreateAggOptions

+ Args RoutineArgs

+ BaseType ResolvableTypeReference

+ Name Name

+ OrderByArgs RoutineArgs

+ Replace bool

+ SFunc string

+ SType ResolvableTypeReference

+ func (*CreateAggregate) StatementTag() string

+ func (*CreateAggregate) StatementType() StatementType

+ func (n *CreateAggregate) String() string

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

+ type CreateDomain struct

+ Collate string

+ Constraints DomainConstraints

+ DataType ResolvableTypeReference

+ Default Expr

+ TypeName *UnresolvedObjectName

+ func (*CreateDomain) StatementTag() string

+ func (*CreateDomain) StatementType() StatementType

+ func (n *CreateDomain) String() string

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

type CreateIndex

+ IndexParams IndexParams

+ type CreateLanguage struct

+ Handler *LanguageHandler

+ Name Name

+ Procedural bool

+ Replace bool

+ Trusted bool

+ func (*CreateLanguage) StatementTag() string

+ func (*CreateLanguage) StatementType() StatementType

+ func (n *CreateLanguage) String() string

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

+ type CreateMaterializedView struct

+ AsSource *Select

+ CheckOption ViewCheckOption

+ ColumnNames NameList

+ IfNotExists bool

+ Name TableName

+ Params StorageParams

+ Tablespace Name

+ Using string

+ WithNoData bool

+ func (*CreateMaterializedView) StatementTag() string

+ func (*CreateMaterializedView) StatementType() StatementType

+ func (n *CreateMaterializedView) String() string

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

+ type CreateOptionType int

+ const AggOptTypeCombineFunc

+ const AggOptTypeDeserialFunc

+ const AggOptTypeFinalFunc

+ const AggOptTypeFinalFuncExtra

+ const AggOptTypeFinalFuncModify

+ const AggOptTypeHypothetical

+ const AggOptTypeInitCond

+ const AggOptTypeMFinalFunc

+ const AggOptTypeMFinalFuncExtra

+ const AggOptTypeMFinalFuncModify

+ const AggOptTypeMInitCond

+ const AggOptTypeMInvFunc

+ const AggOptTypeMSFunc

+ const AggOptTypeMSSpace

+ const AggOptTypeMSType

+ const AggOptTypeParallel

+ const AggOptTypeSSpace

+ const AggOptTypeSerialFunc

+ const AggOptTypeSortOp

+ type CreateProcedure struct

+ Args RoutineArgs

+ Name *UnresolvedObjectName

+ Options []RoutineOption

+ Replace bool

+ func (*CreateProcedure) StatementTag() string

+ func (*CreateProcedure) StatementType() StatementType

+ func (n *CreateProcedure) String() string

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

type CreateTable

+ Inherits TableNames

+ OfType *UnresolvedObjectName

+ PartitionBoundSpec PartitionBoundSpec

+ PartitionOf TableName

+ type CreateTrigger struct

+ Args NameList

+ Constraint bool

+ Deferrable TriggerDeferrableMode

+ Events TriggerEvents

+ ForEachRow bool

+ FuncName *UnresolvedObjectName

+ Name Name

+ OnTable TableName

+ RefTable Name

+ Relations TriggerRelations

+ Replace bool

+ Time TriggerTime

+ When Expr

+ func (*CreateTrigger) StatementTag() string

+ func (*CreateTrigger) StatementType() StatementType

+ func (n *CreateTrigger) String() string

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

type CreateType

+ Base BaseType

+ Composite CompositeType

+ Enum EnumType

+ Range RangeType

type CreateView

+ CheckOption ViewCheckOption

+ IsRecursive bool

+ Options ViewOptions

+ type DetachPartition int

+ const DetachPartitionConcurrently

+ const DetachPartitionFinalize

+ const DetachPartitionNone

+ type DomainConstraint struct

+ Check Expr

+ Constraint Name

+ NotNull bool

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

+ type DomainConstraints []DomainConstraint

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

+ type DropAggregate struct

+ Aggregates []AggregateToDrop

+ DropBehavior DropBehavior

+ IfExists bool

+ func (*DropAggregate) StatementTag() string

+ func (*DropAggregate) StatementType() StatementType

+ func (n *DropAggregate) String() string

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

+ type DropDomain struct

+ DropBehavior DropBehavior

+ IfExists bool

+ Names NameList

+ func (*DropDomain) StatementTag() string

+ func (*DropDomain) StatementType() StatementType

+ func (n *DropDomain) String() string

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

+ type DropLanguage struct

+ DropBehavior DropBehavior

+ IfExists bool

+ Name Name

+ Procedural bool

+ func (*DropLanguage) StatementTag() string

+ func (*DropLanguage) StatementType() StatementType

+ func (n *DropLanguage) String() string

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

+ type DropProcedure struct

+ DropBehavior DropBehavior

+ IfExists bool

+ Procedures []RoutineWithArgs

+ func (*DropProcedure) StatementTag() string

+ func (*DropProcedure) StatementType() StatementType

+ func (n *DropProcedure) String() string

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

+ type DropTrigger struct

+ DropBehavior DropBehavior

+ IfExists bool

+ Name Name

+ OnTable TableName

+ func (*DropTrigger) StatementTag() string

+ func (*DropTrigger) StatementType() StatementType

+ func (n *DropTrigger) String() string

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

+ type EnumType struct

+ Labels []string

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

+ type ExcludeConstraintTableDef struct

+ Predicate Expr

+ Using string

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

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

+ type ExcludeElement struct

+ Elem IndexElem

+ With Operator

+ type FinalFuncModifyType string

+ const FinalFuncModifyReadOnly

+ const FinalFuncModifyReadWrite

+ const FinalFuncModifyShareable

+ type FunctionOption int8

+ const OptionReset

type IndexElem

+ ExcludeOp Operator

+ type IndexParams struct

+ IncludeColumns IndexElemList

+ StorageParams StorageParams

+ Tablespace Name

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

type IndexTableDef

+ IndexParams IndexParams

+ type InitiallyMode int

+ const InitiallyDeferred

+ const InitiallyImmediate

+ const UnspecifiedInitiallyMode

+ type LanguageHandler struct

+ Handler *UnresolvedObjectName

+ Inline *UnresolvedObjectName

+ Validator *UnresolvedObjectName

+ func (h *LanguageHandler) Format(ctx *FmtCtx)

type NamedColumnQualification

+ Collation string

+ Deferrable DeferrableMode

+ Initially InitiallyMode

+ type PartitionBoundSpec struct

+ From Exprs

+ IsDefault bool

+ To Exprs

+ Type PartitionBoundType

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

+ type PartitionBoundType int

+ const PartitionBoundFromTo

+ const PartitionBoundIn

+ const PartitionBoundWith

type PartitionBy

+ Elems IndexElemList

+ Type PartitionByType

type PartitionByType

+ const PartitionByHash

+ type RangeType struct

+ Options []RangeTypeOption

+ Subtype ResolvableTypeReference

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

+ type RangeTypeOption struct

+ MRTypeName *UnresolvedObjectName

+ Option RangeTypeOptionType

+ StrVal string

+ type RangeTypeOptionType int

+ const RangeTypeCanonical

+ const RangeTypeCollation

+ const RangeTypeMultiRangeTypeName

+ const RangeTypeSubtypeDiff

+ const RangeTypeSubtypeOpClass

+ type RefAction struct

+ Action ReferenceAction

+ Columns NameList

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

+ type ReplicaIdentity int

+ const ReplicaIdentityDefault

+ const ReplicaIdentityFull

+ const ReplicaIdentityNothing

+ const ReplicaIdentityUsingIndex

+ type ResetAll struct

+ func (*ResetAll) StatementTag() string

+ func (*ResetAll) StatementType() StatementType

+ func (n *ResetAll) String() string

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

type RoutineOption

+ ResetAll bool

+ ResetParam string

+ type RoutineWithArgs struct

+ Args RoutineArgs

+ Name *UnresolvedObjectName

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

+ type RowLevelSecurity int

+ const RowLevelSecurityDisable

+ const RowLevelSecurityEnable

+ const RowLevelSecurityForce

+ const RowLevelSecurityNoForce

type SequenceOption

+ AsType ResolvableTypeReference

+ type SetConstraints struct

+ All bool

+ Deferred bool

+ Names NameList

+ func (*SetConstraints) StatementTag() string

+ func (*SetConstraints) StatementType() StatementType

+ func (n *SetConstraints) String() string

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

+ type SetRole struct

+ IsLocal bool

+ Name string

+ None bool

+ Reset bool

+ func (*SetRole) StatementTag() string

+ func (*SetRole) StatementType() StatementType

+ func (n *SetRole) String() string

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

+ func (node *SetRole) SetLocalSetStmt()

+ type SetSessionAuthorization struct

+ IsLocal bool

+ Username string

+ func (*SetSessionAuthorization) StatementTag() string

+ func (*SetSessionAuthorization) StatementType() StatementType

+ func (n *SetSessionAuthorization) String() string

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

+ func (node *SetSessionAuthorization) SetLocalSetStmt()

+ type SetStmt interface

+ SetLocalSetStmt func()

type SetVar

+ IsLocal bool

+ func (node *SetVar) SetLocalSetStmt()

+ type StorageType int

+ const StorageExtended

+ const StorageExternal

+ const StorageMain

+ const StoragePlain

type TableDefs

+ func ConvertIdxElemsToTblDefsForColumnNameOnly(idxElems IndexElemList) TableDefs

+ type TriggerDeferrableMode int

+ const TriggerDeferrable

+ const TriggerInitiallyDeferred

+ const TriggerNotDeferrable

+ type TriggerEvent struct

+ Cols NameList

+ Type TriggerEventType

+ type TriggerEventType int

+ const TriggerEventDelete

+ const TriggerEventInsert

+ const TriggerEventTruncate

+ const TriggerEventUpdate

+ type TriggerEvents []TriggerEvent

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

+ type TriggerRelation struct

+ IsOld bool

+ Name string

+ type TriggerRelations []TriggerRelation

+ func (t TriggerRelations) Format(ctx *FmtCtx)

+ type TriggerTime int

+ const TriggerTimeAfter

+ const TriggerTimeBefore

+ const TriggerTimeInsteadOf

type UniqueConstraint

+ IndexParams IndexParams

+ IsPrimary bool

+ NullsDistinct bool

type UniqueConstraintTableDef

+ NullsNotDistinct bool

+ type ViewCheckOption int

+ const ViewCheckOptionCascaded

+ const ViewCheckOptionLocal

+ const ViewCheckOptionUnspecified

+ type ViewOption struct

+ Name string

+ Val Expr

+ type ViewOptions []ViewOption

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

v0.4.0

Feb 14, 2024

Changes in this version

+ const OptionAs1

+ const OptionAs2

+ const OptionCost

+ const OptionLanguage

+ const OptionLeakProof

+ const OptionNullInput

+ const OptionParallel

+ const OptionRows

+ const OptionSecurity

+ const OptionSet

+ const OptionSqlBody

+ const OptionSupport

+ const OptionTransform

+ const OptionVolatility

+ const OptionWindow

+ type AggregateSignature struct

+ All bool

+ Args RoutineArgs

+ OrderByArgs RoutineArgs

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

+ type AlterAggregate struct

+ AggSig *AggregateSignature

+ Name Name

+ Owner string

+ Rename Name

+ Schema string

+ func (*AlterAggregate) StatementTag() string

+ func (*AlterAggregate) StatementType() StatementType

+ func (n *AlterAggregate) String() string

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

+ type AlterCollation struct

+ Name Name

+ Owner string

+ RefreshVersion bool

+ Rename Name

+ Schema string

+ func (*AlterCollation) StatementTag() string

+ func (*AlterCollation) StatementType() StatementType

+ func (n *AlterCollation) String() string

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

+ type AlterConversion struct

+ Name Name

+ Owner string

+ RefreshVersion bool

+ Rename Name

+ Schema string

+ func (*AlterConversion) StatementTag() string

+ func (*AlterConversion) StatementType() StatementType

+ func (n *AlterConversion) String() string

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

+ type AlterDatabase struct

+ Name Name

+ Options []DatabaseOption

+ Owner string

+ RefreshCollationVersion bool

+ ResetAll bool

+ ResetVar string

+ SetVar *SetVar

+ Tablespace string

+ func (*AlterDatabase) StatementTag() string

+ func (*AlterDatabase) StatementType() StatementType

+ func (n *AlterDatabase) String() string

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

+ type AlterDatabaseOption string

+ const OptAllowConnections

+ const OptConnectionLimit

+ const OptIsTemplate

+ type AlterDefaultPrivileges struct

+ DropBehavior DropBehavior

+ ForRole bool

+ Grant bool

+ GrantOption bool

+ Grantees []string

+ Privileges privilege.List

+ Target TargetList

+ TargetRoles []string

+ func (*AlterDefaultPrivileges) StatementTag() string

+ func (*AlterDefaultPrivileges) StatementType() StatementType

+ func (n *AlterDefaultPrivileges) String() string

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

+ type BeginEndBlock struct

+ Statements []Statement

+ func (*BeginEndBlock) StatementTag() string

+ func (*BeginEndBlock) StatementType() StatementType

+ func (n *BeginEndBlock) String() string

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

+ type CommentOnExtension struct

+ Comment *string

+ Name Name

+ func (*CommentOnExtension) StatementTag() string

+ func (*CommentOnExtension) StatementType() StatementType

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

+ func (n *CommentOnExtension) String() string

type CreateDatabase

+ AllowConnections Expr

+ CollationVersion string

+ ConnectionLimit Expr

+ IcuLocale string

+ IcuRules string

+ IsTemplate Expr

+ Locale string

+ LocaleProvider string

+ Oid Expr

+ Owner string

+ Strategy string

+ Tablespace string

+ type CreateExtension struct

+ Cascade bool

+ IfNotExists bool

+ Name Name

+ Schema string

+ Version string

+ func (*CreateExtension) StatementTag() string

+ func (*CreateExtension) StatementType() StatementType

+ func (n *CreateExtension) String() string

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

+ type CreateFunction struct

+ Args RoutineArgs

+ Name *UnresolvedObjectName

+ Options []RoutineOption

+ Replace bool

+ RetType []SimpleColumnDef

+ func (*CreateFunction) StatementTag() string

+ func (*CreateFunction) StatementType() StatementType

+ func (n *CreateFunction) String() string

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

type CreateIndex

+ Include NameList

+ NullsDistinct bool

+ Only bool

+ Tablespace Name

+ Using string

type CreateSchema

+ SchemaElements []Statement

type CreateTable

+ Tablespace Name

+ Using string

+ WithNoData bool

type CreateTableOnCommitSetting

+ const CreateTableOnCommitDeleteRows

+ const CreateTableOnCommitDrop

+ type DatabaseOption struct

+ Opt AlterDatabaseOption

+ Val Expr

type DropDatabase

+ Force bool

+ type DropExtension struct

+ DropBehavior DropBehavior

+ IfExists bool

+ Names NameList

+ func (*DropExtension) StatementTag() string

+ func (*DropExtension) StatementType() StatementType

+ func (n *DropExtension) String() string

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

+ type DropFunction struct

+ DropBehavior DropBehavior

+ Functions []FunctionWithArgs

+ IfExists bool

+ func (*DropFunction) StatementTag() string

+ func (*DropFunction) StatementType() StatementType

+ func (n *DropFunction) String() string

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

+ type FunctionWithArgs struct

+ Args RoutineArgs

+ Name *UnresolvedObjectName

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

type Grant

+ GrantedBy string

+ PrivsWithCols []PrivForCols

+ WithGrantOption bool

type GrantRole

+ GrantedBy string

+ WithOption string

type IndexElem

+ Collation string

+ Expr Expr

+ OpClass *IndexElemOpClass

+ type IndexElemOpClass struct

+ Name string

+ Options []IndexElemOpClassOption

+ type IndexElemOpClassOption struct

+ Param string

+ Val Expr

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

+ type NullInput string

+ const CalledOnNullInput

+ const ReturnsNullOnNullInput

+ const StrictNullInput

+ type Parallel string

+ const ParallelRestricted

+ const ParallelSafe

+ const ParallelUnsafe

+ type PrivForCols struct

+ ColNames NameList

+ Privilege privilege.Kind

+ type Return struct

+ Expr Expr

+ func (*Return) StatementTag() string

+ func (*Return) StatementType() StatementType

+ func (n *Return) String() string

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

type Revoke

+ DropBehavior DropBehavior

+ GrantOptionFor bool

+ GrantedBy string

+ PrivsWithCols []PrivForCols

type RevokeRole

+ DropBehavior DropBehavior

+ GrantedBy string

+ Option string

+ type Routine struct

+ Args RoutineArgs

+ Name Name

+ type RoutineArg struct

+ Default Expr

+ Mode string

+ Name Name

+ Type ResolvableTypeReference

+ type RoutineArgs []*RoutineArg

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

+ type RoutineOption struct

+ Cost Expr

+ Definer bool

+ Definition string

+ External bool

+ IsLeakProof bool

+ Language string

+ LinkSymbol string

+ NullInput NullInput

+ ObjFile string

+ OptionType functionOption

+ Parallel Parallel

+ Rows Expr

+ SetVar *SetVar

+ SqlBody Statement

+ Support string

+ TransformTypes []ResolvableTypeReference

+ Volatility Volatility

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

type SetVar

+ FromCurrent bool

+ type SimpleColumnDef struct

+ Name Name

+ Type ResolvableTypeReference

type TargetList

+ InSchema []string

+ LargeObjects []Expr

+ Names []string

+ Parameters NameList

+ Routines []Routine

+ Sequences NameList

+ TableColumnNames NameList

+ TargetType privilege.ObjectType

v0.3.1

Dec 28, 2023

v0.3.0

Dec 20, 2023

v0.2.0

Dec 11, 2023

Changes in this version

+ type NullLiteral struct

+ func (NullLiteral) AmbiguousFormat() bool

+ func (NullLiteral) Format(ctx *FmtCtx)

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

+ func (d NullLiteral) Size() uintptr

+ func (d NullLiteral) String() string

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

+ func (d NullLiteral) Walk(_ Visitor) Expr

type NumVal

+ func (expr *NumVal) FormattedString() string

type StrVal

+ func (expr *StrVal) WasScannedAsBytes() bool

v0.1.0

Nov 1, 2023

Changes in this version

+ const AllFuncType

+ const AnnotateExplicit

+ const AnnotateShort

+ const AstCross

+ const AstFull

+ const AstHash

+ const AstHaving

+ const AstInner

+ const AstLeft

+ const AstLookup

+ const AstMerge

+ const AstRight

+ const AstWhere

+ const CastExplicit

+ const CastPrepend

+ const CastShort

+ const DistinctFuncType

+ const LikeTableOptAll

+ const MaxPlaceholderIdx

+ const PrettyAlignAndDeindent

+ const PrettyAlignAndExtraIndent

+ const PrettyAlignOnly

+ const PrettyNoAlign

+ const PublicSchema

+ const PublicSchemaName

+ const ScrubDatabase

+ const ScrubTable

+ const SeqOptAs

+ const SeqOptCache

+ const SeqOptCycle

+ const SeqOptIncrement

+ const SeqOptMaxValue

+ const SeqOptMinValue

+ const SeqOptNoCycle

+ const SeqOptOwnedBy

+ const SeqOptStart

+ const SeqOptVirtual

+ const TimestampOutputFormat

+ const TimestampTZOutputFormat

+ var AbsentReturningClause = &NoReturningClause

+ var BinOps = map[BinaryOperator]binOpOverload

+ var CmpOps = cmpOpFixups(map[ComparisonOperator]cmpOpOverload{ ... })

+ var DBoolFalse = &constDBoolFalse

+ var DBoolTrue = &constDBoolTrue

+ var DNull Datum = dNull

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

+ var DecimalCtx = &apd.Context

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

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

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

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

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

+ var ExactCtx = DecimalCtx.WithPrecision(0)

+ 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 LibPQTimePrefix = "0000-01-01"

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

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

+ var NumValAvailDecimalNoFraction = append(decimalLikeTypes, intLikeTypes)

+ var NumValAvailDecimalWithFraction = decimalLikeTypes

+ var NumValAvailInteger = append(intLikeTypes, decimalLikeTypes)

+ var ReturningNothingClause = &ReturningNothing

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

+ var StrValAvailAllParsable = []*types.T

+ var StrValAvailBytes = []*types.T

+ var UnaryOps = unaryOpFixups(map[UnaryOperator]unaryOpOverload{ ... })

+ var UnknownReturnType *types.T

+ func AsString(n NodeFormatter) string

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

+ func AsStringWithFlags(n NodeFormatter, fl FmtFlags) string

+ func CanModifySchema(stmt Statement) bool

+ func CanWriteData(stmt Statement) bool

+ func CheckIsWindowOrAgg(def *FunctionDefinition) error

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

+ func ErrNameString(s string) string

+ func ErrNameStringP(s *string) string

+ func ErrString(n NodeFormatter) string

+ func ExprDebugString(expr Expr) string

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

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

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

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

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

+ func HasReturningClause(clause ReturningClause) bool

+ func IsReferenceSerialType(ref ResolvableTypeReference) bool

+ func IsStmtParallelized(stmt Statement) bool

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

+ 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 NewInvalidFunctionUsageError(class FunctionClass, context string) error

+ func NewInvalidNestedSRFError(context string) error

+ func NewTypeIsNotCompositeError(resolvedType *types.T) error

+ func Pretty(stmt NodeFormatter) string

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

+ func ResolveExisting(ctx context.Context, u *UnresolvedObjectName, r ObjectNameExistingResolver, ...) (bool, ObjectNamePrefix, NameResolutionResult, error)

+ func ResolveTarget(ctx context.Context, u *UnresolvedObjectName, r ObjectNameTargetResolver, ...) (found bool, namePrefix ObjectNamePrefix, scMeta SchemaMeta, err error)

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

+ func Serialize(n NodeFormatter) string

+ func SerializeForDisplay(n NodeFormatter) string

+ func SizeOfDecimal(d apd.Decimal) uintptr

+ func StmtDebugString(stmt Statement) string

+ func TimeFamilyPrecisionToRoundDuration(precision int32) time.Duration

+ func WalkExprConst(v Visitor, expr Expr)

+ func WindowModeName(mode WindowFrameMode) string

+ type AggType int

+ const GeneralAgg

+ const OrderedSetAgg

+ type AliasClause struct

+ Alias Name

+ Cols NameList

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

+ type AliasedTableExpr struct

+ As AliasClause

+ Expr TableExpr

+ IndexFlags *IndexFlags

+ Lateral bool

+ Ordinality bool

+ 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) Resolve(ctx context.Context, r ColumnItemResolver) (srcName *TableName, srcMeta ColumnSourceMeta, err 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

+ type AllTablesSelector struct

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

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

+ func (at *AllTablesSelector) String() string

+ type AlterDatabaseOwner struct

+ Name Name

+ Owner string

+ func (*AlterDatabaseOwner) StatementTag() string

+ func (*AlterDatabaseOwner) StatementType() StatementType

+ func (n *AlterDatabaseOwner) String() string

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

+ type AlterIndex struct

+ Cmds AlterIndexCmds

+ IfExists bool

+ Index TableIndexName

+ 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 AlterRole struct

+ IfExists bool

+ IsRole bool

+ KVOptions KVOptions

+ Name Expr

+ func (*AlterRole) StatementTag() string

+ func (*AlterRole) StatementType() StatementType

+ func (n *AlterRole) String() string

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

+ type AlterSchema struct

+ Cmd AlterSchemaCmd

+ Schema string

+ 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 string

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

+ type AlterSchemaRename struct

+ NewName string

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

+ type AlterSequence struct

+ IfExists bool

+ Name *UnresolvedObjectName

+ Options SequenceOptions

+ 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) StatementTag() string

+ func (*AlterTable) StatementType() StatementType

+ func (n *AlterTable) String() string

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

+ func (node *AlterTable) HoistAddColumnConstraints()

+ type AlterTableAddColumn struct

+ ColumnDef *ColumnTableDef

+ IfNotExists bool

+ func (n *AlterTableAddColumn) String() string

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

+ type AlterTableAddConstraint struct

+ ConstraintDef ConstraintTableDef

+ ValidationBehavior ValidationBehavior

+ func (n *AlterTableAddConstraint) String() string

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

+ 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

+ type AlterTableAlterPrimaryKey struct

+ Columns IndexElemList

+ Interleave *InterleaveDef

+ Sharded *ShardedIndexDef

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

+ type AlterTableCmd interface

+ 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)

+ type AlterTableDropConstraint struct

+ Constraint Name

+ DropBehavior DropBehavior

+ IfExists bool

+ func (n *AlterTableDropConstraint) String() string

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

+ type AlterTableDropNotNull struct

+ Column Name

+ func (n *AlterTableDropNotNull) String() string

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

+ func (node *AlterTableDropNotNull) GetColumn() Name

+ type AlterTableDropStored struct

+ Column Name

+ func (n *AlterTableDropStored) String() string

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

+ func (node *AlterTableDropStored) GetColumn() Name

+ type AlterTableInjectStats struct

+ Stats Expr

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

+ type AlterTableOwner struct

+ Owner string

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

+ type AlterTablePartitionBy struct

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

+ type AlterTableRenameColumn struct

+ Column Name

+ NewName Name

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

+ type AlterTableRenameConstraint struct

+ Constraint Name

+ NewName Name

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

+ type AlterTableSetAudit struct

+ Mode AuditMode

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

+ type AlterTableSetDefault struct

+ Column Name

+ Default Expr

+ func (n *AlterTableSetDefault) String() string

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

+ func (node *AlterTableSetDefault) GetColumn() Name

+ type AlterTableSetNotNull struct

+ Column Name

+ func (n *AlterTableSetNotNull) String() string

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

+ func (node *AlterTableSetNotNull) GetColumn() Name

+ type AlterTableSetSchema struct

+ IfExists bool

+ IsMaterialized bool

+ IsSequence bool

+ IsView bool

+ Name *UnresolvedObjectName

+ Schema string

+ func (*AlterTableSetSchema) StatementTag() string

+ func (*AlterTableSetSchema) StatementType() StatementType

+ func (n *AlterTableSetSchema) String() string

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

+ type AlterTableValidateConstraint struct

+ Constraint Name

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

+ type AlterType struct

+ Cmd AlterTypeCmd

+ Type *UnresolvedObjectName

+ 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 string

+ Placement *AlterTypeAddValuePlacement

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

+ type AlterTypeAddValuePlacement struct

+ Before bool

+ ExistingVal string

+ type AlterTypeCmd interface

+ type AlterTypeOwner struct

+ Owner string

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

+ type AlterTypeRename struct

+ NewName string

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

+ type AlterTypeRenameValue struct

+ NewVal string

+ OldVal string

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

+ type AlterTypeSetSchema struct

+ Schema string

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

+ type Analyze struct

+ Table TableExpr

+ 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) 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 ArgTypes []struct

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

+ func (a ArgTypes) Length() int

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

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

+ func (a ArgTypes) MatchLen(l int) bool

+ func (a ArgTypes) String() string

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

+ 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) 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) 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) 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

+ type Backup struct

+ AppendToLatest bool

+ AsOf AsOfClause

+ IncrementalFrom Exprs

+ Nested bool

+ Options BackupOptions

+ Subdir Expr

+ Targets *TargetList

+ To StringOrPlaceholderOptList

+ 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 BackupDetails int

+ const BackupDefaultDetails

+ const BackupFileDetails

+ const BackupRangeDetails

+ type BackupOptions struct

+ CaptureRevisionHistory bool

+ Detached bool

+ EncryptionKMSURI StringOrPlaceholderOptList

+ EncryptionPassphrase Expr

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

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

+ func (o BackupOptions) IsDefault() bool

+ type BeginTransaction struct

+ Modes TransactionModes

+ func (*BeginTransaction) StatementTag() string

+ func (*BeginTransaction) StatementType() StatementType

+ func (n *BeginTransaction) String() string

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

+ type BinOp struct

+ LeftType *types.T

+ NullableArgs bool

+ ReturnType *types.T

+ RightType *types.T

+ Volatility Volatility

+ type BinaryExpr struct

+ Fn *BinOp

+ Left Expr

+ Operator BinaryOperator

+ Right Expr

+ func NewTypedBinaryExpr(op 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) 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 BinaryOperator int

+ const Bitand

+ const Bitor

+ const Bitxor

+ const Concat

+ const Div

+ const FloorDiv

+ const JSONFetchText

+ const JSONFetchTextPath

+ const JSONFetchVal

+ const JSONFetchValPath

+ const LShift

+ const Minus

+ const Mod

+ const Mult

+ const NumBinaryOperators

+ const Plus

+ const Pow

+ const RShift

+ func (i BinaryOperator) String() string

+ type CCLOnlyStatement interface

+ type CTE struct

+ Mtr MaterializeClause

+ Name AliasClause

+ Stmt Statement

+ type Call struct

+ Procedure *FuncExpr

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

+ func (c *Call) StatementTag() string

+ func (c *Call) StatementType() StatementType

+ func (c *Call) String() string

+ type CancelQueries struct

+ IfExists bool

+ Queries *Select

+ 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) StatementTag() string

+ func (*CancelSessions) StatementType() StatementType

+ func (n *CancelSessions) String() string

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

+ type CannedOptPlan struct

+ Plan string

+ 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) Format(ctx *FmtCtx)

+ func (node *CaseExpr) String() string

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

+ 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) Format(ctx *FmtCtx)

+ func (node *CastExpr) String() string

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

+ type CheckConstraintTableDef struct

+ Expr Expr

+ Hidden bool

+ Name Name

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

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

+ type ClientNoticeSender interface

+ SendClientNotice func(ctx context.Context, notice error)

+ type CmpOp struct

+ LeftType *types.T

+ NullableArgs bool

+ RightType *types.T

+ Volatility Volatility

+ 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) Format(ctx *FmtCtx)

+ 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) 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 string

+ Expr Expr

+ func NewTypedColumnAccessExpr(expr TypedExpr, colName string, 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) 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

+ 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 uint32

+ func (ColumnID) SafeValue()

+ 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) Resolve(ctx context.Context, r ColumnItemResolver) (ColumnResolutionResult, 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

+ type ColumnItemResolver interface

+ FindSourceMatchingName func(ctx context.Context, tn TableName) (res NumResolutionResults, prefix *TableName, srcMeta ColumnSourceMeta, ...)

+ FindSourceProvidingColumn func(ctx context.Context, col Name) (prefix *TableName, srcMeta ColumnSourceMeta, colHint int, err error)

+ Resolve func(ctx context.Context, prefix *TableName, srcMeta ColumnSourceMeta, colHint int, ...) (ColumnResolutionResult, error)

+ type ColumnMutationCmd interface

+ GetColumn func() Name

+ type ColumnQualification interface

+ type ColumnResolutionResult interface

+ ColumnResolutionResult func()

+ type ColumnSourceMeta interface

+ ColumnSourceMeta func()

+ type ColumnTableDef struct

+ CheckExprs []ColumnTableDefCheckExpr

+ Computed struct{ ... }

+ DefaultExpr struct{ ... }

+ Family struct{ ... }

+ IsSerial bool

+ Name Name

+ Nullable struct{ ... }

+ PrimaryKey struct{ ... }

+ References struct{ ... }

+ Type ResolvableTypeReference

+ Unique bool

+ UniqueConstraintName Name

+ 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) IsComputed() bool

+ func (node *ColumnTableDef) String() string

+ type ColumnTableDefCheckExpr struct

+ ConstraintName Name

+ Expr Expr

+ type CommentOnColumn struct

+ Comment *string

+ func (*CommentOnColumn) StatementTag() string

+ func (*CommentOnColumn) StatementType() StatementType

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

+ func (n *CommentOnColumn) String() string

+ type CommentOnDatabase struct

+ Comment *string

+ Name Name

+ 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) StatementTag() string

+ func (*CommentOnIndex) StatementType() StatementType

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

+ func (n *CommentOnIndex) String() string

+ type CommentOnTable struct

+ Comment *string

+ Table *UnresolvedObjectName

+ func (*CommentOnTable) StatementTag() string

+ func (*CommentOnTable) StatementType() StatementType

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

+ func (n *CommentOnTable) String() string

+ type CommitTransaction struct

+ func (*CommitTransaction) StatementTag() string

+ func (*CommitTransaction) StatementType() StatementType

+ func (n *CommitTransaction) String() string

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

+ type CommonLookupFlags struct

+ AvoidCached bool

+ IncludeDropped bool

+ IncludeOffline bool

+ RequireMutable bool

+ Required bool

+ type ComparisonExpr struct

+ Fn *CmpOp

+ Left Expr

+ Operator ComparisonOperator

+ Right Expr

+ SubOperator ComparisonOperator

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

+ func NewTypedComparisonExprWithSubOp(op, subOp 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) 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 ComparisonOperator int

+ const All

+ const Any

+ const ContainedBy

+ const Contains

+ const EQ

+ const GE

+ const GT

+ const ILike

+ const In

+ const IsDistinctFrom

+ const IsNotDistinctFrom

+ const JSONAllExists

+ const JSONExists

+ const JSONSomeExists

+ const LE

+ const LT

+ const Like

+ const NE

+ const NotILike

+ const NotIn

+ const NotLike

+ const NotRegIMatch

+ const NotRegMatch

+ const NotSimilarTo

+ const NumComparisonOperators

+ const Overlaps

+ const RegIMatch

+ const RegMatch

+ const SimilarTo

+ const Some

+ func (i ComparisonOperator) HasSubOperator() bool

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

+ func (i ComparisonOperator) String() string

+ type CompositeDatum interface

+ IsComposite func() bool

+ type CompositeKeyMatchMethod int

+ const MatchFull

+ const MatchPartial

+ const MatchSimple

+ func (c CompositeKeyMatchMethod) String() string

+ type Constant interface

+ AvailableTypes func() []*types.T

+ DesirableTypes func() []*types.T

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

+ type ConstraintTableDef interface

+ SetName func(name Name)

+ type ControlJobs struct

+ Command JobCommand

+ Jobs *Select

+ 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) StatementType() StatementType

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

+ func (n *ControlJobsForSchedules) StatementTag() string

+ func (n *ControlJobsForSchedules) String() string

+ type ControlSchedules struct

+ Command ScheduleCommand

+ Schedules *Select

+ 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 CopyFormatText

+ type CopyFrom struct

+ Columns NameList

+ Options CopyOptions

+ Stdin bool

+ Table TableName

+ func (*CopyFrom) StatementTag() string

+ func (*CopyFrom) StatementType() StatementType

+ func (n *CopyFrom) String() string

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

+ type CopyOptions struct

+ CopyFormat CopyFormat

+ Destination Expr

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

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

+ func (o CopyOptions) IsDefault() bool

+ type CreateChangefeed struct

+ Options KVOptions

+ SinkURI Expr

+ Targets TargetList

+ 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

+ Encoding string

+ IfNotExists bool

+ Name Name

+ Template string

+ func (*CreateDatabase) StatementTag() string

+ func (*CreateDatabase) StatementType() StatementType

+ func (n *CreateDatabase) String() string

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

+ type CreateIndex struct

+ Columns IndexElemList

+ Concurrently bool

+ IfNotExists bool

+ Interleave *InterleaveDef

+ Inverted bool

+ Name Name

+ PartitionBy *PartitionBy

+ Predicate Expr

+ Sharded *ShardedIndexDef

+ StorageParams StorageParams

+ Storing NameList

+ Table TableName

+ Unique bool

+ 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 Expr

+ func (*CreateRole) StatementTag() string

+ func (*CreateRole) StatementType() StatementType

+ func (n *CreateRole) String() string

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

+ type CreateSchema struct

+ AuthRole string

+ IfNotExists bool

+ Schema string

+ func (n *CreateSchema) StatementTag() string

+ func (n *CreateSchema) StatementType() StatementType

+ func (n *CreateSchema) String() string

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

+ type CreateSequence struct

+ IfNotExists bool

+ Name TableName

+ Options SequenceOptions

+ Persistence Persistence

+ 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) StatementTag() string

+ func (*CreateStats) StatementType() StatementType

+ func (n *CreateStats) String() string

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

+ type CreateStatsOptions struct

+ AsOf AsOfClause

+ Throttling float64

+ 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

+ Interleave *InterleaveDef

+ OnCommit CreateTableOnCommitSetting

+ PartitionBy *PartitionBy

+ Persistence Persistence

+ StorageParams StorageParams

+ Table TableName

+ func (n *CreateTable) StatementTag() string

+ func (n *CreateTable) StatementType() StatementType

+ 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 CreateType struct

+ EnumLabels []string

+ TypeName *UnresolvedObjectName

+ Variety CreateTypeVariety

+ 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

+ func (*CreateView) StatementTag() string

+ func (*CreateView) StatementType() StatementType

+ func (n *CreateView) String() string

+ func (node *CreateView) 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 ParseTimeContext, s string, t *types.T) (_ *DArray, dependsOnContext bool, _ error)

+ func (d *DArray) AmbiguousFormat() bool

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

+ func (d *DArray) FirstIndex() int

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

+ func (d *DArray) IsComposite() bool

+ func (d *DArray) Len() int

+ 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(_ Visitor) Expr

+ func (node *DArray) String() string

+ type DBitArray struct

+ 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) Format(ctx *FmtCtx)

+ 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) String() string

+ type DBool bool

+ func MakeDBool(d DBool) *DBool

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

+ func (*DBool) AmbiguousFormat() bool

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

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

+ 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) String() string

+ type DBox2D struct

+ func NewDBox2D(b geo.CartesianBoundingBox) *DBox2D

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

+ func (*DBox2D) AmbiguousFormat() bool

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

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

+ 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) String() string

+ type DBytes string

+ func NewDBytes(d DBytes) *DBytes

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

+ func (*DBytes) AmbiguousFormat() bool

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

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

+ func (d *DBytes) Size() uintptr

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

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

+ func (node *DBytes) String() string

+ type DCollatedString struct

+ Contents string

+ Key []byte

+ Locale string

+ func (*DCollatedString) AmbiguousFormat() bool

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

+ func (d *DCollatedString) IsComposite() bool

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

+ func (d *DCollatedString) Size() uintptr

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

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

+ func (node *DCollatedString) String() string

+ type DDate struct

+ func NewDDate(d pgdate.Date) *DDate

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

+ func (*DDate) AmbiguousFormat() bool

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

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

+ 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) String() string

+ type DDecimal struct

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

+ func (*DDecimal) AmbiguousFormat() bool

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

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

+ func (d *DDecimal) IsComposite() 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) String() string

+ type DEnum struct

+ EnumTyp *types.T

+ LogicalRep string

+ PhysicalRep []byte

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

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

+ func (d *DEnum) AmbiguousFormat() bool

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

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

+ func (d *DEnum) MinWriteable() (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

+ type DFloat float64

+ func NewDFloat(d DFloat) *DFloat

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

+ func (*DFloat) AmbiguousFormat() bool

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

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

+ func (d *DFloat) IsComposite() 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) String() string

+ type DGeography struct

+ func NewDGeography(g geo.Geography) *DGeography

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

+ func (*DGeography) AmbiguousFormat() bool

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

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

+ 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) String() string

+ type DGeometry struct

+ func NewDGeometry(g geo.Geometry) *DGeometry

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

+ func (*DGeometry) AmbiguousFormat() bool

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

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

+ 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) String() string

+ type DIPAddr struct

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

+ func (*DIPAddr) AmbiguousFormat() bool

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

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

+ 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) String() string

+ type DInt int64

+ func NewDInt(d DInt) *DInt

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

+ func (*DInt) AmbiguousFormat() bool

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

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

+ 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) String() string

+ type DInterval struct

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

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

+ func (*DInterval) AmbiguousFormat() bool

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

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

+ func (d *DInterval) Size() uintptr

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

+ func (d *DInterval) ValueAsString() string

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

+ func (node *DInterval) String() string

+ type DJSON struct

+ func NewDJSON(j json.JSON) *DJSON

+ func (*DJSON) AmbiguousFormat() bool

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

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

+ 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) String() string

+ type DOid struct

+ func MakeDOid(d DInt) DOid

+ func NewDOid(d DInt) *DOid

+ func (*DOid) AmbiguousFormat() bool

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

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

+ 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) String() string

+ type DOidWrapper struct

+ Oid oid.Oid

+ Wrapped Datum

+ func (d *DOidWrapper) AmbiguousFormat() bool

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

+ 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) String() string

+ type DString string

+ func NewDString(d string) *DString

+ func (*DString) AmbiguousFormat() bool

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

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

+ func (d *DString) Size() uintptr

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

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

+ func (node *DString) String() string

+ type DTime timeofday.TimeOfDay

+ func MakeDTime(t timeofday.TimeOfDay) *DTime

+ func ParseDTime(ctx ParseTimeContext, s string, precision time.Duration) (_ *DTime, dependsOnContext bool, _ error)

+ func (*DTime) AmbiguousFormat() bool

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

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

+ 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) String() string

+ type DTimeTZ struct

+ func NewDTimeTZ(t timetz.TimeTZ) *DTimeTZ

+ func NewDTimeTZFromOffset(t timeofday.TimeOfDay, offsetSecs int32) *DTimeTZ

+ func ParseDTimeTZ(ctx ParseTimeContext, s string, precision time.Duration) (_ *DTimeTZ, dependsOnContext bool, _ error)

+ func (*DTimeTZ) AmbiguousFormat() bool

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

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

+ 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) String() string

+ type DTimestamp struct

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

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

+ func ParseDTimestamp(ctx ParseTimeContext, s string, precision time.Duration) (_ *DTimestamp, dependsOnContext bool, _ error)

+ func (*DTimestamp) AmbiguousFormat() bool

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

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

+ 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) String() string

+ type DTimestampTZ struct

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

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

+ func ParseDTimestampTZ(ctx ParseTimeContext, s string, precision time.Duration) (_ *DTimestampTZ, dependsOnContext bool, _ error)

+ func (*DTimestampTZ) AmbiguousFormat() bool

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

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

+ 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) String() string

+ type DTuple struct

+ D Datums

+ func (*DTuple) AmbiguousFormat() bool

+ func (d *DTuple) AssertSorted()

+ func (d *DTuple) ContainsNull() bool

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

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

+ 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(_ Visitor) Expr

+ func (node *DTuple) String() string

+ type DUuid struct

+ func NewDUuid(d DUuid) *DUuid

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

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

+ func (*DUuid) AmbiguousFormat() bool

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

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

+ 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) String() string

+ type DatabaseListFlags struct

+ ExplicitPrefix bool

+ type DatabaseLookupFlags = CommonLookupFlags

+ type Datum interface

+ AmbiguousFormat func() bool

+ Size func() uintptr

+ func NewDNameFromDString(d *DString) Datum

+ func ParseAndRequireString(t *types.T, s string, ctx ParseTimeContext) (d Datum, dependsOnContext bool, err error)

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

+ func SampleDatum(t *types.T) Datum

+ func UnwrapDatum(d Datum) Datum

+ type Datums []Datum

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

+ func (d Datums) Len() int

+ func (node *Datums) String() string

+ type Deallocate struct

+ Name Name

+ func (*Deallocate) StatementType() StatementType

+ func (n *Deallocate) StatementTag() string

+ func (n *Deallocate) String() string

+ func (node *Deallocate) Format(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) 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

+ Limit *Limit

+ OrderBy OrderBy

+ Returning ReturningClause

+ Table TableExpr

+ Where *Where

+ With *With

+ func (*Delete) StatementTag() string

+ func (n *Delete) StatementType() StatementType

+ func (n *Delete) String() string

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

+ type DescriptorCoverage int32

+ const AllDescriptors

+ const RequestedDescriptors

+ type DesiredObjectKind int

+ 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) StatementTag() string

+ func (*Discard) StatementType() StatementType

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

+ func (node *Discard) String() string

+ type DiscardMode int

+ const DiscardModeAll

+ type DistinctOn []Expr

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

+ type DropBehavior int

+ const DropCascade

+ const DropDefault

+ const DropRestrict

+ func (d DropBehavior) String() string

+ type DropDatabase struct

+ DropBehavior DropBehavior

+ IfExists bool

+ Name Name

+ func (*DropDatabase) StatementTag() string

+ func (*DropDatabase) StatementType() StatementType

+ func (n *DropDatabase) String() string

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

+ type DropIndex struct

+ Concurrently bool

+ DropBehavior DropBehavior

+ IfExists bool

+ IndexList TableIndexNames

+ func (*DropIndex) StatementTag() string

+ func (*DropIndex) StatementType() StatementType

+ func (n *DropIndex) String() string

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

+ type DropRole struct

+ IfExists bool

+ IsRole bool

+ Names Exprs

+ func (*DropRole) StatementTag() string

+ func (*DropRole) StatementType() StatementType

+ func (n *DropRole) String() string

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

+ type DropSchema struct

+ DropBehavior DropBehavior

+ IfExists bool

+ Names []string

+ 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) 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) StatementTag() string

+ func (*DropTable) StatementType() StatementType

+ func (n *DropTable) String() string

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

+ type DropType struct

+ DropBehavior DropBehavior

+ IfExists bool

+ Names []*UnresolvedObjectName

+ 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) StatementTag() string

+ func (*DropView) StatementType() StatementType

+ func (n *DropView) String() string

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

+ type EvalContextTestingKnobs struct

+ AssertBinaryExprReturnTypes bool

+ AssertFuncExprReturnTypes bool

+ AssertUnaryExprReturnTypes bool

+ DisableOptimizerRuleProbability float64

+ OptimizerCostPerturbation float64

+ type EvalDatabase interface

+ LookupSchema func(ctx context.Context, dbName, scName string) (found bool, scMeta SchemaMeta, err error)

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

+ ResolveTableName func(ctx context.Context, tn *TableName) (ID, error)

+ type EvalPlanner interface

+ EvalSubquery func(expr *Subquery) (Datum, error)

+ ParseType func(sql string) (*types.T, error)

+ type EvalSessionAccessor interface

+ GetSessionVar func(ctx context.Context, settingName string, missingOk bool) (bool, string, error)

+ HasAdminRole func(ctx context.Context) (bool, error)

+ HasRoleOption func(ctx context.Context, roleOption roleoption.Option) (bool, error)

+ SetSessionVar func(ctx context.Context, settingName, newValue string) error

+ type Execute struct

+ DiscardRows bool

+ Name Name

+ Params Exprs

+ 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) StatementTag() string

+ func (*Explain) StatementType() StatementType

+ func (n *Explain) String() string

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

+ type ExplainAnalyzeDebug struct

+ Statement Statement

+ func (*ExplainAnalyzeDebug) StatementTag() string

+ func (*ExplainAnalyzeDebug) StatementType() StatementType

+ func (n *ExplainAnalyzeDebug) String() string

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

+ type ExplainFlag uint8

+ const ExplainFlagAnalyze

+ const ExplainFlagCatalog

+ const ExplainFlagDebug

+ const ExplainFlagEnv

+ const ExplainFlagTypes

+ const ExplainFlagVerbose

+ func (f ExplainFlag) String() string

+ type ExplainMode uint8

+ const ExplainDistSQL

+ 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) 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 Exprs []Expr

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

+ func (node *Exprs) String() string

+ type FamilyTableDef struct

+ Columns NameList

+ Name Name

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

+ type FmtCtx struct

+ func NewFmtCtx(f FmtFlags) *FmtCtx

+ func NewFmtCtxEx(f FmtFlags, ann *Annotations) *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) FormatTypeReference(ref ResolvableTypeReference)

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

+ func (ctx *FmtCtx) Printf(f string, args ...interface{})

+ func (ctx *FmtCtx) SetIndexedTypeFormat(fn func(*FmtCtx, *OIDTypeReference))

+ func (ctx *FmtCtx) SetIndexedVarFormat(fn func(ctx *FmtCtx, idx int))

+ func (ctx *FmtCtx) SetPlaceholderFormat(placeholderFn func(_ *FmtCtx, _ *Placeholder))

+ func (ctx *FmtCtx) SetReformatTableNames(tableNameFmt func(*FmtCtx, *TableName))

+ func (ctx *FmtCtx) WithFlags(flags FmtFlags, fn func())

+ func (ctx *FmtCtx) WithReformatTableNames(tableNameFmt func(*FmtCtx, *TableName), fn func())

+ type FmtFlags int

+ const FmtAlwaysGroupExprs

+ const FmtAlwaysQualifyTableNames

+ const FmtAnonymize

+ const FmtArrayToString

+ const FmtBareIdentifiers

+ const FmtBareStrings

+ const FmtCheckEquivalence

+ const FmtExport

+ const FmtHideConstants

+ const FmtPGCatalog

+ const FmtPGIndexDef

+ const FmtParsable

+ const FmtParsableNumerics

+ const FmtPgwireText

+ const FmtSerializable

+ const FmtShowPasswords

+ const FmtShowTableAliases

+ const FmtShowTypes

+ const FmtSimple

+ const FmtSymbolicSubqueries

+ func (f FmtFlags) EncodeFlags() lex.EncodeFlags

+ func (f FmtFlags) HasAnyFlags(subset FmtFlags) bool

+ func (f FmtFlags) HasFlags(subset FmtFlags) bool

+ type ForeignKeyConstraintTableDef struct

+ Actions ReferenceActions

+ FromCols NameList

+ Match CompositeKeyMatchMethod

+ Name Name

+ Table TableName

+ ToCols NameList

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

+ 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

+ OrderBy OrderBy

+ Type funcType

+ WindowDef *WindowDef

+ func NewTypedFuncExpr(ref ResolvableFunctionReference, aggQualifier funcType, exprs TypedExprs, ...) *FuncExpr

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

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

+ func (node *FuncExpr) CanHandleNulls() bool

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

+ func (node *FuncExpr) IsDistSQLBlocklist() bool

+ func (node *FuncExpr) IsWindowFunctionApplication() bool

+ func (node *FuncExpr) ResolvedOverload() *Overload

+ func (node *FuncExpr) String() string

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

+ type FunctionClass int

+ const AggregateClass

+ const GeneratorClass

+ const NormalClass

+ const SQLClass

+ const WindowClass

+ type FunctionDefinition struct

+ Definition []overloadImpl

+ Name string

+ func NewFunctionDefinition(name string, props *FunctionProperties, def []Overload) *FunctionDefinition

+ func (fd *FunctionDefinition) Format(ctx *FmtCtx)

+ func (fd *FunctionDefinition) String() string

+ type FunctionProperties struct

+ AmbiguousReturnType bool

+ AvailableOnPublicSchema bool

+ Category string

+ Class FunctionClass

+ DistsqlBlocklist bool

+ HasSequenceArguments bool

+ NullableArgs bool

+ Private bool

+ ReturnLabels []string

+ Undocumented bool

+ UnsupportedWithIssue int

+ func (fp *FunctionProperties) ShouldDocument() bool

+ type FunctionReference interface

+ type Grant struct

+ Grantees NameList

+ Privileges privilege.List

+ Targets TargetList

+ func (*Grant) StatementTag() string

+ func (*Grant) StatementType() StatementType

+ func (n *Grant) String() string

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

+ type GrantRole struct

+ AdminOption bool

+ Members NameList

+ Roles NameList

+ func (*GrantRole) StatementTag() string

+ func (*GrantRole) StatementType() StatementType

+ func (n *GrantRole) String() string

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

+ type GroupBy []Expr

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

+ 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) MatchLen(l int) bool

+ func (HomogeneousType) String() string

+ func (HomogeneousType) Types() []*types.T

+ type ID uint32

+ func (ID) SafeValue()

+ 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) 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) 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

+ CreateDefs TableDefs

+ CreateFile Expr

+ FileFormat string

+ Files Exprs

+ Into bool

+ IntoCols NameList

+ Options KVOptions

+ Table *TableName

+ func (*Import) StatementTag() string

+ func (n *Import) StatementType() StatementType

+ func (n *Import) String() string

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

+ type IndexElem struct

+ Column Name

+ Direction Direction

+ NullsOrder NullsOrder

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

+ type IndexElemList []IndexElem

+ func (l *IndexElemList) Format(ctx *FmtCtx)

+ type IndexFlags struct

+ Direction Direction

+ IgnoreForeignKeys bool

+ Index UnrestrictedName

+ IndexID IndexID

+ NoIndexJoin bool

+ 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 uint32

+ type IndexTableDef struct

+ Columns IndexElemList

+ Interleave *InterleaveDef

+ Inverted bool

+ Name Name

+ PartitionBy *PartitionBy

+ 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) 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) NumVars() int

+ 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) 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 (n *Insert) StatementType() StatementType

+ func (n *Insert) String() string

+ func (node *Insert) DefaultValues() bool

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

+ type InterleaveDef struct

+ DropBehavior DropBehavior

+ Fields NameList

+ Parent TableName

+ func (node *InterleaveDef) 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) 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) 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) Format(ctx *FmtCtx)

+ func (node *IsOfTypeExpr) ResolvedTypes() []*types.T

+ func (node *IsOfTypeExpr) String() string

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

+ type IsolationLevel int

+ const SerializableIsolation

+ const UnspecifiedIsolation

+ func (i IsolationLevel) String() string

+ 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 (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) ToRoleOptions(...) (roleoption.List, error)

+ 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 Limit struct

+ Count Expr

+ LimitAll bool

+ Offset Expr

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

+ type ListPartition struct

+ Exprs Exprs

+ Name UnrestrictedName

+ Subpartition *PartitionBy

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

+ type LockingClause []*LockingItem

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

+ type LockingItem struct

+ 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 LockWaitSkip

+ func (p LockingWaitPolicy) Format(ctx *FmtCtx)

+ func (p LockingWaitPolicy) Max(p2 LockingWaitPolicy) LockingWaitPolicy

+ func (p LockingWaitPolicy) String() string

+ type MaterializeClause struct

+ Materialize bool

+ Set bool

+ 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) ToStrings() []string

+ func (list *NameList) String() string

+ type NameParts = [4]string

+ type NameResolutionResult interface

+ NameResolutionResult func()

+ type NamedColumnQualification struct

+ Name Name

+ Qualification ColumnQualification

+ type NaturalJoinCond struct

+ func (NaturalJoinCond) Format(ctx *FmtCtx)

+ 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) 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) Format(ctx *FmtCtx)

+ func (node *NullIfExpr) String() string

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

+ type Nullability int

+ const NotNull

+ const Null

+ const SilentNull

+ type NullsOrder int8

+ const DefaultNullsOrder

+ const NullsFirst

+ const NullsLast

+ func (n NullsOrder) String() string

+ type NumResolutionResults int

+ const ExactlyOne

+ const MoreThanOne

+ const NoResults

+ 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

+ DesiredObjectKind DesiredObjectKind

+ DesiredTableDescKind RequiredTableKind

+ func ObjectLookupFlagsWithRequired() ObjectLookupFlags

+ func ObjectLookupFlagsWithRequiredTableKind(kind RequiredTableKind) ObjectLookupFlags

+ type ObjectName interface

+ Catalog func() string

+ FQString func() string

+ Object func() string

+ Schema func() string

+ func NewQualifiedObjectName(catalog, schema, object string, kind DesiredObjectKind) ObjectName

+ type ObjectNameExistingResolver interface

+ LookupObject func(ctx context.Context, flags ObjectLookupFlags, dbName, scName, obName string) (found bool, objMeta NameResolutionResult, err error)

+ 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) Resolve(ctx context.Context, r ObjectNameTargetResolver, curDb string, ...) (found bool, scMeta SchemaMeta, err error)

+ func (tp *ObjectNamePrefix) Schema() string

+ func (tp *ObjectNamePrefix) String() string

+ type ObjectNameTargetResolver interface

+ LookupSchema func(ctx context.Context, dbName, scName string) (found bool, scMeta SchemaMeta, err error)

+ type ObserverStatement interface

+ type OnConflict struct

+ ArbiterPredicate Expr

+ Columns NameList

+ DoNothing bool

+ Exprs UpdateExprs

+ Where *Where

+ func (oc *OnConflict) IsUpsertAlias() bool

+ type OnJoinCond struct

+ Expr Expr

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

+ type Operator interface

+ 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) 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 Overload struct

+ IgnoreVolatilityCheck bool

+ Info string

+ PreferredOverload bool

+ ReturnType ReturnTyper

+ SpecializedVecBuiltin SpecializedVectorizedBuiltin

+ Types TypeList

+ Volatility Volatility

+ func (b Overload) FixedReturnType() *types.T

+ func (b Overload) Signature(simplify bool) string

+ 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) 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) StatementTag() string

+ func (*ParenSelect) StatementType() StatementType

+ func (n *ParenSelect) String() string

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

+ type ParenTableExpr struct

+ Expr TableExpr

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

+ func (node *ParenTableExpr) String() string

+ type ParseTimeContext interface

+ GetRelativeParseTime func() time.Time

+ type PartitionBy struct

+ Fields NameList

+ List []ListPartition

+ Range []RangePartition

+ func (node *PartitionBy) 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) 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) 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) Value(idx PlaceholderIdx) (TypedExpr, bool)

+ type PlaceholderTypes []*types.T

+ func (pt PlaceholderTypes) AssertAllSet() error

+ func (pt PlaceholderTypes) Equals(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)

+ func (p *PlaceholderTypesInfo) ValueType(idx PlaceholderIdx) (_ *types.T, ok bool)

+ type Prepare struct

+ Name Name

+ Statement Statement

+ Types []ResolvableTypeReference

+ func (*Prepare) StatementTag() string

+ func (*Prepare) StatementType() StatementType

+ func (n *Prepare) String() string

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

+ type PrettyAlignMode int

+ type PrettyCfg struct

+ Align PrettyAlignMode

+ Case func(string) string

+ JSONFmt bool

+ LineWidth int

+ Simplify bool

+ TabWidth int

+ UseTabs bool

+ func DefaultPrettyCfg() PrettyCfg

+ func (p *PrettyCfg) Doc(f NodeFormatter) pretty.Doc

+ func (p *PrettyCfg) Pretty(stmt NodeFormatter) string

+ type PrimaryKeyConstraint struct

+ type PrivilegedAccessor interface

+ LookupNamespaceID func(ctx context.Context, parentID int64, name string) (DInt, bool, error)

+ LookupZoneConfigByNamespaceID func(ctx context.Context, id int64) (DBytes, bool, error)

+ type QueryArguments []TypedExpr

+ func (qa QueryArguments) String() string

+ 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) 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 UnrestrictedName

+ Subpartition *PartitionBy

+ To Exprs

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

+ type ReadWriteMode int

+ const ReadOnly

+ const ReadWrite

+ const UnspecifiedReadWriteMode

+ func (ro ReadWriteMode) String() string

+ type ReferenceAction int

+ const Cascade

+ const NoAction

+ const Restrict

+ const SetDefault

+ const SetNull

+ func (ra 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) StatementTag() string

+ func (*RefreshMaterializedView) StatementType() StatementType

+ func (n *RefreshMaterializedView) String() string

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

+ type ReleaseSavepoint struct

+ Savepoint Name

+ func (*ReleaseSavepoint) StatementTag() string

+ func (*ReleaseSavepoint) StatementType() StatementType

+ func (n *ReleaseSavepoint) String() string

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

+ type Relocate struct

+ RelocateLease bool

+ Rows *Select

+ TableOrIndex TableIndexName

+ func (*Relocate) StatementType() StatementType

+ func (n *Relocate) StatementTag() string

+ func (n *Relocate) String() string

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

+ type RenameColumn struct

+ IfExists bool

+ Name Name

+ NewName Name

+ Table TableName

+ 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) 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) 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) 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) StatementTag() string

+ func (*ReparentDatabase) StatementType() StatementType

+ func (n *ReparentDatabase) String() string

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

+ type RequiredTableKind int

+ const ResolveAnyTableKind

+ const ResolveRequireSequenceDesc

+ const ResolveRequireTableDesc

+ const ResolveRequireTableOrViewDesc

+ const ResolveRequireViewDesc

+ func (r RequiredTableKind) String() string

+ type ResolvableFunctionReference struct

+ func WrapFunction(n string) ResolvableFunctionReference

+ func (fn *ResolvableFunctionReference) Format(ctx *FmtCtx)

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

+ func (fn *ResolvableFunctionReference) String() string

+ type ResolvableTypeReference interface

+ SQLString func() string

+ type Restore struct

+ AsOf AsOfClause

+ DescriptorCoverage DescriptorCoverage

+ From []StringOrPlaceholderOptList

+ Options RestoreOptions

+ Subdir Expr

+ Targets TargetList

+ func (*Restore) StatementTag() string

+ func (*Restore) StatementType() StatementType

+ func (n *Restore) String() string

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

+ type RestoreOptions struct

+ DecryptionKMSURI StringOrPlaceholderOptList

+ Detached bool

+ EncryptionPassphrase Expr

+ IntoDB Expr

+ SkipMissingFKs bool

+ SkipMissingSequenceOwners bool

+ SkipMissingSequences bool

+ SkipMissingViews 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

+ Grantees NameList

+ Privileges privilege.List

+ Targets TargetList

+ 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 NameList

+ Roles NameList

+ func (*RevokeRole) StatementTag() string

+ func (*RevokeRole) StatementType() StatementType

+ func (n *RevokeRole) String() string

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

+ type RollbackToSavepoint struct

+ Savepoint Name

+ func (*RollbackToSavepoint) StatementTag() string

+ func (*RollbackToSavepoint) StatementType() StatementType

+ func (n *RollbackToSavepoint) String() string

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

+ type RollbackTransaction struct

+ func (*RollbackTransaction) StatementTag() string

+ func (*RollbackTransaction) StatementType() StatementType

+ func (n *RollbackTransaction) String() string

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

+ type RowsFromExpr struct

+ Items Exprs

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

+ type Savepoint struct

+ Name Name

+ func (*Savepoint) StatementTag() string

+ func (*Savepoint) StatementType() StatementType

+ func (n *Savepoint) String() string

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

+ type ScalarProperties struct

+ InWindowFunc bool

+ SeenAggregate bool

+ SeenGenerator bool

+ SeenWindowApplication bool

+ func (sp *ScalarProperties) Clear()

+ type Scatter struct

+ From Exprs

+ TableOrIndex TableIndexName

+ To Exprs

+ 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

+ ScheduleLabel Expr

+ ScheduleOptions KVOptions

+ Targets *TargetList

+ To StringOrPlaceholderOptList

+ func (*ScheduledBackup) StatementTag() string

+ func (*ScheduledBackup) StatementType() StatementType

+ func (n *ScheduledBackup) String() string

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

+ type ScheduledJobExecutorType int

+ const InvalidExecutor

+ const ScheduledBackupExecutor

+ func (t ScheduledJobExecutorType) InternalName() string

+ func (t ScheduledJobExecutorType) UserName() string

+ type SchemaLookupFlags = CommonLookupFlags

+ type SchemaMeta interface

+ SchemaMeta func()

+ type Scrub struct

+ AsOf AsOfClause

+ Database Name

+ Options ScrubOptions

+ Table *UnresolvedObjectName

+ Typ ScrubType

+ 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 Select struct

+ Limit *Limit

+ Locking LockingClause

+ OrderBy OrderBy

+ Select SelectStatement

+ With *With

+ 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) 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

+ AsOfTimestamp *hlc.Timestamp

+ IVarContainer IndexedVarContainer

+ Placeholders PlaceholderInfo

+ Properties SemaProperties

+ SearchPath sessiondata.SearchPath

+ TypeResolver TypeReferenceResolver

+ func MakeSemaContext() SemaContext

+ func (sc *SemaContext) GetTypeResolver() TypeReferenceResolver

+ type SemaProperties struct

+ Derived ScalarProperties

+ func (s *SemaProperties) IsSet(rejectFlags SemaRejectFlags) bool

+ 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 RejectSpecial

+ const RejectStableOperators

+ const RejectSubqueries

+ const RejectVolatileFunctions

+ const RejectWindowApplications

+ type SequenceOperators interface

+ GetLatestValueInSessionForSequence func(ctx context.Context, seqName *TableName) (int64, error)

+ GetSerialSequenceNameFromColumn func(ctx context.Context, tableName *TableName, columnName Name) (*TableName, error)

+ IncrementSequence func(ctx context.Context, seqName *TableName) (int64, error)

+ SetSequenceValue func(ctx context.Context, seqName *TableName, newVal int64, isCalled bool) error

+ type SequenceOption struct

+ 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) StatementTag() string

+ func (*SetClusterSetting) StatementType() StatementType

+ func (n *SetClusterSetting) String() string

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

+ type SetSessionAuthorizationDefault struct

+ 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) StatementTag() string

+ func (*SetSessionCharacteristics) StatementType() StatementType

+ func (n *SetSessionCharacteristics) String() string

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

+ type SetTracing struct

+ Values Exprs

+ 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) StatementTag() string

+ func (*SetTransaction) StatementType() StatementType

+ func (n *SetTransaction) String() string

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

+ type SetVar struct

+ Name string

+ Values Exprs

+ func (*SetVar) StatementTag() string

+ func (*SetVar) StatementType() StatementType

+ func (n *SetVar) String() string

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

+ type SetZoneConfig struct

+ AllIndexes bool

+ Options KVOptions

+ SetDefault bool

+ YAMLConfig Expr

+ 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

+ type ShowBackup struct

+ Details BackupDetails

+ InCollection Expr

+ Options KVOptions

+ Path Expr

+ ShouldIncludeSchemas bool

+ func (*ShowBackup) StatementTag() string

+ func (*ShowBackup) StatementType() StatementType

+ func (n *ShowBackup) String() string

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

+ type ShowClusterSetting struct

+ Name string

+ 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) 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) StatementTag() string

+ func (*ShowColumns) StatementType() StatementType

+ func (n *ShowColumns) String() string

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

+ type ShowConstraints struct

+ Table *UnresolvedObjectName

+ func (*ShowConstraints) StatementTag() string

+ func (*ShowConstraints) StatementType() StatementType

+ func (n *ShowConstraints) String() string

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

+ type ShowCreate struct

+ Name *UnresolvedObjectName

+ func (*ShowCreate) StatementTag() string

+ func (*ShowCreate) StatementType() StatementType

+ func (n *ShowCreate) String() string

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

+ type ShowDatabaseIndexes struct

+ Database Name

+ WithComment bool

+ 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) StatementTag() string

+ func (*ShowDatabases) StatementType() StatementType

+ func (n *ShowDatabases) String() string

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

+ type ShowEnums struct

+ func (*ShowEnums) StatementTag() string

+ func (*ShowEnums) StatementType() StatementType

+ func (n *ShowEnums) String() string

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

+ type ShowFingerprints struct

+ Table *UnresolvedObjectName

+ func (*ShowFingerprints) StatementTag() string

+ func (*ShowFingerprints) StatementType() StatementType

+ func (n *ShowFingerprints) String() string

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

+ type ShowGrants struct

+ Grantees NameList

+ Targets *TargetList

+ 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) 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) StatementTag() string

+ func (*ShowIndexes) StatementType() StatementType

+ func (n *ShowIndexes) String() string

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

+ type ShowJobs struct

+ Automatic bool

+ Block bool

+ Jobs *Select

+ Schedules *Select

+ func (*ShowJobs) StatementTag() string

+ func (*ShowJobs) StatementType() StatementType

+ func (n *ShowJobs) String() string

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

+ type ShowLastQueryStatistics struct

+ 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) 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) 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) StatementTag() string

+ func (*ShowRangeForRow) StatementType() StatementType

+ func (n *ShowRangeForRow) String() string

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

+ type ShowRanges struct

+ DatabaseName Name

+ TableOrIndex TableIndexName

+ func (*ShowRanges) StatementTag() string

+ func (*ShowRanges) StatementType() StatementType

+ func (n *ShowRanges) String() string

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

+ type ShowRoleGrants struct

+ Grantees NameList

+ Roles NameList

+ func (*ShowRoleGrants) StatementTag() string

+ func (*ShowRoleGrants) StatementType() StatementType

+ func (n *ShowRoleGrants) String() string

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

+ type ShowRoles struct

+ func (*ShowRoles) StatementTag() string

+ func (*ShowRoles) StatementType() StatementType

+ func (n *ShowRoles) String() string

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

+ type ShowSavepointStatus struct

+ 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) StatementTag() string

+ func (*ShowSchedules) StatementType() StatementType

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

+ func (n *ShowSchedules) String() string

+ type ShowSchemas struct

+ Database Name

+ 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) 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) StatementTag() string

+ func (*ShowSessions) StatementType() StatementType

+ func (n *ShowSessions) String() string

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

+ type ShowSyntax struct

+ Statement string

+ func (*ShowSyntax) StatementTag() string

+ func (*ShowSyntax) StatementType() StatementType

+ func (n *ShowSyntax) String() string

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

+ type ShowTableStats struct

+ Table *UnresolvedObjectName

+ UsingJSON bool

+ 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) StatementTag() string

+ func (*ShowTables) StatementType() StatementType

+ func (n *ShowTables) String() string

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

+ type ShowTraceForSession struct

+ Compact bool

+ TraceType ShowTraceType

+ 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) 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) StatementTag() string

+ func (*ShowTransactions) StatementType() StatementType

+ func (n *ShowTransactions) String() string

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

+ type ShowTypes struct

+ func (*ShowTypes) StatementTag() string

+ func (*ShowTypes) StatementType() StatementType

+ func (n *ShowTypes) String() string

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

+ type ShowUsers struct

+ 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) StatementTag() string

+ func (*ShowVar) StatementType() StatementType

+ func (n *ShowVar) String() string

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

+ type ShowZoneConfig struct

+ func (*ShowZoneConfig) StatementTag() string

+ func (*ShowZoneConfig) StatementType() StatementType

+ func (n *ShowZoneConfig) String() string

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

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

+ type SpecializedVectorizedBuiltin int

+ const SubstringStringIntInt

+ type Split struct

+ ExpireExpr Expr

+ Rows *Select

+ TableOrIndex TableIndexName

+ func (*Split) StatementTag() string

+ func (*Split) StatementType() StatementType

+ func (n *Split) String() string

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

+ type Statement interface

+ StatementTag func() string

+ StatementType func() StatementType

+ func MakeExplain(options []string, stmt Statement) (Statement, error)

+ type StatementSource struct

+ Statement Statement

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

+ type StatementType int

+ const Ack

+ const CopyIn

+ const DDL

+ const Rows

+ const RowsAffected

+ const Unknown

+ func (i StatementType) String() string

+ type StorageParam struct

+ Key Name

+ Value Expr

+ type StorageParams []StorageParam

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

+ 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 (node *Subquery) Format(ctx *FmtCtx)

+ func (node *Subquery) SetType(t *types.T)

+ func (node *Subquery) String() string

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

+ type SubqueryExpr interface

+ SubqueryExpr func()

+ type TableDef interface

+ type TableDefs []TableDef

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

+ type TableExpr interface

+ 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 MakeTableName(db, tbl Name) TableName

+ func MakeTableNameFromPrefix(prefix ObjectNamePrefix, object Name) TableName

+ func MakeTableNameWithSchema(db, schema, tbl Name) TableName

+ func MakeUnqualifiedTableName(tbl Name) TableName

+ func NewTableName(db, tbl Name) *TableName

+ func NewUnqualifiedTableName(tbl Name) *TableName

+ func (o *TableName) Object() string

+ func (o *TableName) ToUnresolvedObjectName() *UnresolvedObjectName

+ func (t *TableName) Equals(other *TableName) bool

+ func (t *TableName) FQString() string

+ func (t *TableName) Format(ctx *FmtCtx)

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

+ func (t *TableName) String() string

+ 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 (n *TableRef) Format(ctx *FmtCtx)

+ func (n *TableRef) String() string

+ type TargetList struct

+ Databases NameList

+ ForRoles bool

+ Roles NameList

+ Schemas []string

+ Tables TablePatterns

+ Tenant roachpb.TenantID

+ Types []*UnresolvedObjectName

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

+ type TenantOperator interface

+ CreateTenant func(ctx context.Context, tenantID uint64, tenantInfo []byte) error

+ DestroyTenant func(ctx context.Context, tenantID uint64) error

+ 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) 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) 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) 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

+ MatchLen func(l int) bool

+ String func() string

+ Types func() []*types.T

+ type TypeName struct

+ func MakeNewQualifiedTypeName(db, schema, typ string) TypeName

+ func MakeUnqualifiedTypeName(typ Name) TypeName

+ func NewUnqualifiedTypeName(typ Name) *TypeName

+ func (o *TypeName) Object() string

+ func (o *TypeName) ToUnresolvedObjectName() *UnresolvedObjectName

+ func (t *TypeName) FQString() string

+ func (t *TypeName) Format(ctx *FmtCtx)

+ func (t *TypeName) String() 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) 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

+ 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)

+ func TypeCheckSameTypedExprs(ctx context.Context, semaCtx *SemaContext, desired *types.T, exprs ...Expr) ([]TypedExpr, *types.T, error)

+ type TypedExprs []TypedExpr

+ func (node *TypedExprs) String() string

+ 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) Format(ctx *FmtCtx)

+ func (node *UnaryExpr) String() string

+ func (node *UnaryExpr) TypedInnerExpr() TypedExpr

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

+ type UnaryOp struct

+ ReturnType *types.T

+ Typ *types.T

+ Volatility Volatility

+ type UnaryOperator int

+ const NumUnaryOperators

+ const UnaryCbrt

+ const UnaryComplement

+ const UnaryMinus

+ const UnarySqrt

+ func (i UnaryOperator) String() string

+ type UnionClause struct

+ All bool

+ Left *Select

+ Right *Select

+ Type UnionType

+ func (*UnionClause) StatementTag() string

+ func (*UnionClause) StatementType() StatementType

+ func (n *UnionClause) String() string

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

+ type UnionType int

+ const ExceptOp

+ const IntersectOp

+ const UnionOp

+ func (i UnionType) String() string

+ type UniqueConstraint struct

+ type UniqueConstraintTableDef struct

+ PrimaryKey bool

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

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

+ 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 (u UnqualifiedStar) NormalizeVarName() (VarName, error)

+ func (u UnqualifiedStar) String() string

+ 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 (n *UnresolvedName) ResolveFunction(searchPath sessiondata.SearchPath) (*FunctionDefinition, error)

+ func (u *UnresolvedName) Format(ctx *FmtCtx)

+ func (u *UnresolvedName) String() string

+ func (u *UnresolvedName) ToUnresolvedObjectName(idx AnnotationIdx) (*UnresolvedObjectName, error)

+ type UnresolvedObjectName struct

+ NumParts int

+ Parts [3]string

+ func NewUnresolvedObjectName(numParts int, parts [3]string, annotationIdx AnnotationIdx) (*UnresolvedObjectName, error)

+ 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) ToTableName() TableName

+ func (u *UnresolvedObjectName) ToUnresolvedName() *UnresolvedName

+ type UnrestrictedName string

+ func (node *UnrestrictedName) String() string

+ func (u *UnrestrictedName) Format(ctx *FmtCtx)

+ type Unsplit struct

+ All bool

+ Rows *Select

+ TableOrIndex TableIndexName

+ func (*Unsplit) StatementTag() string

+ func (*Unsplit) StatementType() StatementType

+ func (n *Unsplit) String() string

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

+ type Update struct

+ Exprs UpdateExprs

+ From TableExprs

+ Limit *Limit

+ OrderBy OrderBy

+ Returning ReturningClause

+ Table TableExpr

+ Where *Where

+ With *With

+ func (*Update) StatementTag() string

+ func (n *Update) StatementType() StatementType

+ 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 ValuesClause struct

+ Rows []Exprs

+ func (*ValuesClause) StatementTag() string

+ func (*ValuesClause) StatementType() StatementType

+ func (n *ValuesClause) String() string

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

+ type ValuesClauseWithNames struct

+ Names NameList

+ 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 (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 Visitor interface

+ VisitPost func(expr Expr) (newNode Expr)

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

+ type Volatility int8

+ const VolatilityImmutable

+ const VolatilityLeakProof

+ const VolatilityStable

+ const VolatilityVolatile

+ func VolatilityFromPostgres(provolatile string, proleakproof bool) (Volatility, error)

+ func (v Volatility) String() string

+ func (v Volatility) ToPostgres() (provolatile string, proleakproof bool)

+ 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 WindowFrameExclusion

+ Mode WindowFrameMode

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

+ type WindowFrameBound struct

+ BoundType WindowFrameBoundType

+ OffsetExpr Expr

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

+ func (node *WindowFrameBound) HasOffset() bool

+ type WindowFrameBoundType int

+ const CurrentRow

+ const OffsetFollowing

+ const OffsetPreceding

+ const UnboundedFollowing

+ const UnboundedPreceding

+ func (ft WindowFrameBoundType) IsOffset() bool

+ type WindowFrameBounds struct

+ EndBound *WindowFrameBound

+ StartBound *WindowFrameBound

+ func (node *WindowFrameBounds) HasOffset() bool

+ type WindowFrameExclusion int

+ const ExcludeCurrentRow

+ const ExcludeGroup

+ const ExcludeTies

+ const NoExclusion

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

+ type WindowFrameMode int

+ const GROUPS

+ const RANGE

+ const ROWS

+ type With struct

+ CTEList []*CTE

+ Recursive bool

+ func (node *With) 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