ast

type AST ¶

type AST struct {
	Statements []Statement
}

AST represents the root of the Abstract Syntax Tree

func NewAST() *AST

func (a AST) Children() []Node

func (a *AST) Span() models.Span

func (a AST) TokenLiteral() string

type AlterColumnOperation ¶

type AlterColumnOperation int

AlterColumnOperation represents operations that can be performed on columns

const (
	AlterColumnSetDefault AlterColumnOperation = iota
	AlterColumnDropDefault
	AlterColumnSetNotNull
	AlterColumnDropNotNull
)

func (a *AlterColumnOperation) Children() []Node

func (a *AlterColumnOperation) TokenLiteral() string

type AlterConnectorOperation ¶

type AlterConnectorOperation struct {
	Properties map[string]string
	URL        string
	Owner      *AlterConnectorOwner
}

AlterConnectorOperation represents operations that can be performed on a connector

func (a AlterConnectorOperation) Children() []Node

func (a AlterConnectorOperation) TokenLiteral() string

type AlterConnectorOwner ¶

type AlterConnectorOwner struct {
	IsUser bool
	Name   string
}

AlterConnectorOwner represents the new owner of a connector

type AlterOperation ¶

type AlterOperation interface {
	Node
	// contains filtered or unexported methods
}

AlterOperation represents the operation to be performed

type AlterPolicyOpType ¶

type AlterPolicyOpType int

AlterPolicyOpType represents the type of policy alteration

const (
	RenamePolicy AlterPolicyOpType = iota
	ModifyPolicy
)

type AlterPolicyOperation ¶

type AlterPolicyOperation struct {
	Type      AlterPolicyOpType
	NewName   string
	To        []string
	Using     Expression
	WithCheck Expression
}

AlterPolicyOperation represents operations that can be performed on a policy

func (a AlterPolicyOperation) Children() []Node

func (a AlterPolicyOperation) TokenLiteral() string

type AlterRoleOpType ¶

type AlterRoleOpType int

AlterRoleOpType represents the type of role alteration

const (
	RenameRole AlterRoleOpType = iota
	AddMember
	DropMember
	SetConfig
	ResetConfig
	WithOptions
)

type AlterRoleOperation ¶

type AlterRoleOperation struct {
	Type        AlterRoleOpType
	NewName     string
	Options     []RoleOption
	MemberName  string
	ConfigName  string
	ConfigValue Expression
	InDatabase  string
}

AlterRoleOperation represents operations that can be performed on a role

func (a AlterRoleOperation) Children() []Node

func (a AlterRoleOperation) TokenLiteral() string

type AlterStatement ¶

type AlterStatement struct {
	Type      AlterType
	Name      string // Name of the object being altered
	Operation AlterOperation
}

AlterStatement represents an ALTER statement

func (a AlterStatement) Children() []Node

func (a AlterStatement) TokenLiteral() string

type AlterTableAction ¶

type AlterTableAction struct {
	Type       string // ADD COLUMN, DROP COLUMN, MODIFY COLUMN, etc.
	ColumnName string
	ColumnDef  *ColumnDef
	Constraint *TableConstraint
}

AlterTableAction represents an action in ALTER TABLE

func (a AlterTableAction) Children() []Node

func (a AlterTableAction) TokenLiteral() string

type AlterTableOpType ¶

type AlterTableOpType int

AlterTableOpType represents the type of table alteration

const (
	AddConstraint AlterTableOpType = iota
	AddColumn
	AddProjection
	AlterColumn
	ChangeColumn
	ClearProjection
	DropColumn
	DropConstraint
	DropPartition
	DropProjection
	MaterializeProjection
	ModifyColumn
	RenameColumn
	RenameConstraint
	RenamePartitions
	RenameTable
)

type AlterTableOperation ¶

type AlterTableOperation struct {
	Type             AlterTableOpType
	ColumnKeyword    bool                  // Used for AddColumn
	IfNotExists      bool                  // Used for AddColumn, AddPartition
	IfExists         bool                  // Used for DropColumn, DropConstraint, DropPartition
	ColumnDef        *ColumnDef            // Used for AddColumn
	ColumnPosition   *ColumnPosition       // Used for AddColumn, ChangeColumn, ModifyColumn
	Constraint       *TableConstraint      // Used for AddConstraint
	ProjectionName   *Ident                // Used for AddProjection, DropProjection
	ProjectionSelect *Select               // Used for AddProjection
	PartitionName    *Ident                // Used for MaterializeProjection, ClearProjection
	OldColumnName    *Ident                // Used for RenameColumn
	NewColumnName    *Ident                // Used for RenameColumn
	TableName        ObjectName            // Used for RenameTable
	NewTableName     ObjectName            // Used for RenameTable
	OldPartitions    []*Expression         // Used for RenamePartitions
	NewPartitions    []*Expression         // Used for RenamePartitions
	Partitions       []*Partition          // Used for AddPartitions
	DropBehavior     DropBehavior          // Used for DropColumn, DropConstraint
	ConstraintName   *Ident                // Used for DropConstraint
	OldName          *Ident                // Used for RenameConstraint
	NewName          *Ident                // Used for RenameConstraint
	ColumnName       *Ident                // Used for AlterColumn
	AlterColumnOp    *AlterColumnOperation // Used for AlterColumn
	CascadeDrops     bool                  // Used for DropColumn, DropConstraint
}

AlterTableOperation represents operations that can be performed on a table

func (a AlterTableOperation) Children() []Node

func (a AlterTableOperation) TokenLiteral() string

type AlterTableStatement ¶

type AlterTableStatement struct {
	Table   string
	Actions []AlterTableAction
}

AlterTableStatement represents an ALTER TABLE statement

func (a AlterTableStatement) Children() []Node

func (a AlterTableStatement) TokenLiteral() string

type AlterType ¶

type AlterType int

AlterType represents the type of object being altered

const (
	AlterTypeTable AlterType = iota
	AlterTypeRole
	AlterTypePolicy
	AlterTypeConnector
)

type ArrayBracketType ¶

type ArrayBracketType int

const (
	NoBrackets ArrayBracketType = iota
	AngleBrackets
	SquareBrackets
	Parentheses
)

type ArrayElemTypeDef ¶

type ArrayElemTypeDef struct {
	Type     *DataType
	Size     *uint64
	Brackets ArrayBracketType
}

ArrayElemTypeDef represents array element type definition

func (a *ArrayElemTypeDef) String() string

type ArrayType ¶

type ArrayType struct {
	ElementType *ArrayElemTypeDef
}

Basic data types

func (t *ArrayType) String() string

type AttachedToken ¶

type AttachedToken struct {
	Token TokenWithSpan
}

AttachedToken is a wrapper over TokenWithSpan that ignores the token and source location in comparisons and hashing.

This type is used when the token and location is not relevant for semantics, but is still needed for accurate source location tracking.

Note: ALL AttachedTokens are equal.

Examples:

Same token, different location are equal:

// commas @ line 1, column 10
tok1 := NewTokenWithSpan(
    Token{Type: Comma},
    Span{Start: Location{Line: 1, Column: 10}, End: Location{Line: 1, Column: 11}},
)
// commas @ line 2, column 20
tok2 := NewTokenWithSpan(
    Token{Type: Comma},
    Span{Start: Location{Line: 2, Column: 20}, End: Location{Line: 2, Column: 21}},
)

// token with locations are *not* equal
fmt.Println(tok1 != tok2) // true
// attached tokens are equal
fmt.Println(AttachedToken{tok1} == AttachedToken{tok2}) // true

Different token, different location are equal:

// commas @ line 1, column 10
tok1 := NewTokenWithSpan(
    Token{Type: Comma},
    Span{Start: Location{Line: 1, Column: 10}, End: Location{Line: 1, Column: 11}},
)
// period @ line 2, column 20
tok2 := NewTokenWithSpan(
    Token{Type: Period},
    Span{Start: Location{Line: 2, Column: 20}, End: Location{Line: 2, Column: 21}},
)

// token with locations are *not* equal
fmt.Println(tok1 != tok2) // true
// attached tokens are equal
fmt.Println(AttachedToken{tok1} == AttachedToken{tok2}) // true

func NewAttachedToken(token TokenWithSpan) AttachedToken

func WrapToken(token TokenWithSpan) AttachedToken

func (a AttachedToken) Compare(other AttachedToken) int

func (a AttachedToken) Empty() AttachedToken

func (a AttachedToken) Equal(other AttachedToken) bool

func (a AttachedToken) GoString() string

func (a AttachedToken) Hash(h hash.Hash)

func (a AttachedToken) String() string

func (a AttachedToken) UnwrapToken() TokenWithSpan

type BetweenExpression ¶

type BetweenExpression struct {
	Expr  Expression
	Lower Expression
	Upper Expression
	Not   bool
}

BetweenExpression represents expr BETWEEN lower AND upper

func (b BetweenExpression) Children() []Node

func (b BetweenExpression) TokenLiteral() string

type BinaryExpression ¶

type BinaryExpression struct {
	Left     Expression
	Operator string
	Right    Expression
	Not      bool                  // For NOT (expr)
	CustomOp *CustomBinaryOperator // For PostgreSQL custom operators
}

BinaryExpression represents operations like WHERE column = value

func GetBinaryExpression() *BinaryExpression

func (b BinaryExpression) Children() []Node

func (e *BinaryExpression) Span() models.Span

func (b *BinaryExpression) TokenLiteral() string

type BinaryLength ¶

type BinaryLength struct {
	Length uint64
	IsMax  bool
}

BinaryLength represents binary length information

func (b *BinaryLength) String() string

type BinaryOperator ¶

type BinaryOperator int

BinaryOperator represents binary operators in SQL expressions

const (
	// BinaryOpNone represents no operator (zero value)
	BinaryOpNone BinaryOperator = iota
	// BinaryPlus represents addition operator, e.g. a + b
	BinaryPlus
	// BinaryMinus represents subtraction operator, e.g. a - b
	BinaryMinus
	// Multiply represents multiplication operator, e.g. a * b
	Multiply
	// Divide represents division operator, e.g. a / b
	Divide
	// Modulo represents modulo operator, e.g. a % b
	Modulo
	// StringConcat represents string/array concatenation operator, e.g. a || b
	StringConcat
	// Gt represents greater than operator, e.g. a > b
	Gt
	// Lt represents less than operator, e.g. a < b
	Lt
	// GtEq represents greater than or equal operator, e.g. a >= b
	GtEq
	// LtEq represents less than or equal operator, e.g. a <= b
	LtEq
	// Spaceship represents spaceship operator, e.g. a <=> b
	Spaceship
	// Eq represents equality operator, e.g. a = b
	Eq
	// NotEq represents inequality operator, e.g. a <> b
	NotEq
	// And represents logical AND operator, e.g. a AND b
	And
	// Or represents logical OR operator, e.g. a OR b
	Or
	// Xor represents logical XOR operator, e.g. a XOR b
	Xor
	// BitwiseOr represents bitwise OR operator, e.g. a | b
	BitwiseOr
	// BitwiseAnd represents bitwise AND operator, e.g. a & b
	BitwiseAnd
	// BitwiseXor represents bitwise XOR operator, e.g. a ^ b
	BitwiseXor
	// DuckIntegerDivide represents DuckDB integer division operator, e.g. a // b
	DuckIntegerDivide
	// MyIntegerDivide represents MySQL DIV integer division operator
	MyIntegerDivide
	// PGBitwiseXor represents PostgreSQL bitwise XOR operator, e.g. a # b
	PGBitwiseXor
	// PGBitwiseShiftLeft represents PostgreSQL bitwise shift left operator, e.g. a << b
	PGBitwiseShiftLeft
	// PGBitwiseShiftRight represents PostgreSQL bitwise shift right operator, e.g. a >> b
	PGBitwiseShiftRight
	// PGExp represents PostgreSQL exponentiation operator, e.g. a ^ b
	PGExp
	// PGOverlap represents PostgreSQL overlap operator, e.g. a && b
	PGOverlap
	// PGRegexMatch represents PostgreSQL case-sensitive regex match operator, e.g. a ~ b
	PGRegexMatch
	// PGRegexIMatch represents PostgreSQL case-insensitive regex match operator, e.g. a ~* b
	PGRegexIMatch
	// PGRegexNotMatch represents PostgreSQL case-sensitive regex non-match operator, e.g. a !~ b
	PGRegexNotMatch
	// PGRegexNotIMatch represents PostgreSQL case-insensitive regex non-match operator, e.g. a !~* b
	PGRegexNotIMatch
	// PGLikeMatch represents PostgreSQL case-sensitive LIKE match operator, e.g. a ~~ b
	PGLikeMatch
	// PGILikeMatch represents PostgreSQL case-insensitive LIKE match operator, e.g. a ~~* b
	PGILikeMatch
	// PGNotLikeMatch represents PostgreSQL case-sensitive NOT LIKE match operator, e.g. a !~~ b
	PGNotLikeMatch
	// PGNotILikeMatch represents PostgreSQL case-insensitive NOT LIKE match operator, e.g. a !~~* b
	PGNotILikeMatch
	// PGStartsWith represents PostgreSQL starts-with operator, e.g. a ^@ b
	PGStartsWith
	// Arrow represents JSON field/array element access operator, e.g. a -> b
	Arrow
	// LongArrow represents JSON field/array element access with text conversion operator, e.g. a ->> b
	LongArrow
	// HashArrow represents JSON path access operator, e.g. a #> b
	HashArrow
	// HashLongArrow represents JSON path access with text conversion operator, e.g. a #>> b
	HashLongArrow
	// AtAt represents PostgreSQL text/JSON search operator, e.g. a @@ b
	AtAt
	// AtArrow represents PostgreSQL contains operator, e.g. a @> b
	AtArrow
	// ArrowAt represents PostgreSQL contained by operator, e.g. a <@ b
	ArrowAt
	// HashMinus represents PostgreSQL JSON delete operator, e.g. a #- b
	HashMinus
	// AtQuestion represents PostgreSQL JSON path exists operator, e.g. a @? b
	AtQuestion
	// Question represents PostgreSQL JSON key exists operator, e.g. a ? b
	Question
	// QuestionAnd represents PostgreSQL JSON all keys exist operator, e.g. a ?& b
	QuestionAnd
	// QuestionPipe represents PostgreSQL JSON any key exists operator, e.g. a ?| b
	QuestionPipe
	// Overlaps represents SQL OVERLAPS operator for datetime periods
	Overlaps
)

func (op BinaryOperator) String() string

type BinaryType ¶

type BinaryType struct {
	Length *BinaryLength
}

Basic data types

func (t *BinaryType) String() string

type BooleanType ¶

type BooleanType struct{}

Basic data types

func (*BooleanType) String() string

type CaseExpression ¶

type CaseExpression struct {
	Value       Expression // Optional CASE value
	WhenClauses []WhenClause
	ElseClause  Expression
}

CaseExpression represents a CASE expression

func (c CaseExpression) Children() []Node

func (c CaseExpression) TokenLiteral() string

type CastExpression ¶

type CastExpression struct {
	Expr Expression
	Type string
}

CastExpression represents CAST(expr AS type)

func (c CastExpression) Children() []Node

func (e *CastExpression) Span() models.Span

func (c CastExpression) TokenLiteral() string

type CharLengthUnits ¶

type CharLengthUnits int

CharLengthUnits represents possible units for characters

const (
	Characters CharLengthUnits = iota
	Octets
)

func (u CharLengthUnits) String() string

type CharacterLength ¶

type CharacterLength struct {
	Length uint64
	Unit   *CharLengthUnits
}

CharacterLength represents character length information

func (c *CharacterLength) String() string

type CharacterType ¶

type CharacterType struct {
	Length *CharacterLength
}

Basic data types

func (t *CharacterType) String() string

type ClusteredBy ¶

type ClusteredBy struct {
	Columns []Node
	Buckets int
}

ClusteredBy represents CLUSTERED BY clause

func (c *ClusteredBy) Children() []Node

func (c *ClusteredBy) TokenLiteral() string

type ColumnConstraint ¶

type ColumnConstraint struct {
	Type          string // NOT NULL, UNIQUE, PRIMARY KEY, etc.
	Default       Expression
	References    *ReferenceDefinition
	Check         Expression
	AutoIncrement bool
}

ColumnConstraint represents a column constraint

func (c ColumnConstraint) Children() []Node

func (c *ColumnConstraint) String() string

func (c ColumnConstraint) TokenLiteral() string

type ColumnDef ¶

type ColumnDef struct {
	Name        string
	Type        string
	Constraints []ColumnConstraint
}

ColumnDef represents a column definition in CREATE TABLE

func (c ColumnDef) Children() []Node

func (c *ColumnDef) String() string

func (c ColumnDef) TokenLiteral() string

type ColumnPosition ¶

type ColumnPosition struct {
	First    bool
	After    *Ident
	Position int
}

ColumnPosition represents the position of a column in a table

type CommentDef ¶

type CommentDef struct {
	Text string
}

CommentDef represents a comment on a database object

func (c *CommentDef) Children() []Node

func (c *CommentDef) TokenLiteral() string

type CommonTableExpr ¶

type CommonTableExpr struct {
	Name         string
	Columns      []string
	Statement    Statement
	Materialized *bool // TODO: Add MATERIALIZED/NOT MATERIALIZED parsing support
}

CommonTableExpr represents a single Common Table Expression in a WITH clause. It supports optional column specifications and any statement type as the CTE query. Phase 2 Complete: Full parser support with column specifications.

func (c CommonTableExpr) Children() []Node

func (c CommonTableExpr) TokenLiteral() string

type CreateIndexStatement ¶

type CreateIndexStatement struct {
	Unique      bool
	IfNotExists bool
	Name        string
	Table       string
	Columns     []IndexColumn
	Using       string
	Where       Expression
}

CreateIndexStatement represents a CREATE INDEX statement

func (c CreateIndexStatement) Children() []Node

func (c CreateIndexStatement) TokenLiteral() string

type CreateTable ¶

type CreateTable struct {
	Name                  ObjectName
	Columns               []ColumnDef
	Constraints           []TableConstraint
	Options               *[]SqlOption
	IfNotExists           bool
	Temporary             bool
	External              bool
	Stored                bool
	Transient             bool
	OrReplace             bool
	Global                *bool
	Volatile              bool
	Iceberg               bool
	HiveDistribution      HiveDistributionStyle
	HiveFormats           *HiveFormat
	TableProperties       []SqlOption
	WithOptions           []SqlOption
	FileFormat            *FileFormat
	Location              *string
	Query                 *Query
	WithoutRowID          bool
	Like                  *ObjectName
	Clone                 *ObjectName
	Engine                *TableEngine
	Comment               *CommentDef
	AutoIncrementOffset   *uint32
	DefaultCharset        *string
	Collation             *string
	OnCommit              *OnCommit
	OnCluster             *Ident
	PrimaryKey            *Expr
	OrderBy               *OneOrManyWithParens[Expr]
	PartitionBy           *Expr
	ClusterBy             *WrappedCollection[[]Ident]
	ClusteredBy           *ClusteredBy
	Strict                bool
	CopyGrants            bool
	EnableSchemaEvolution *bool
	ChangeTracking        *bool
	DataRetentionDays     *uint64
	MaxDataExtensionDays  *uint64
	DefaultDDLCollation   *string
	AggregationPolicy     *ObjectName
	RowAccessPolicy       *RowAccessPolicy
	Tags                  *[]Tag
	BaseLocation          *string
	ExternalVolume        *string
	Catalog               *string
	CatalogSync           *string
	SerializationPolicy   *StorageSerializationPolicy
}

CreateTable represents a CREATE TABLE statement

func (c *CreateTable) Children() []Node

func (c *CreateTable) TokenLiteral() string

type CreateTableBuilder ¶

type CreateTableBuilder struct {
	OrReplace             bool
	Temporary             bool
	External              bool
	Global                *bool
	IfNotExists           bool
	Transient             bool
	Volatile              bool
	Iceberg               bool
	Name                  ObjectName
	Columns               []ColumnDef
	Constraints           []TableConstraint
	HiveDistribution      HiveDistributionStyle
	HiveFormats           *HiveFormat
	TableProperties       []SqlOption
	WithOptions           []SqlOption
	FileFormat            *FileFormat
	Location              *string
	Query                 *Query
	WithoutRowID          bool
	Like                  *ObjectName
	Clone                 *ObjectName
	Engine                *TableEngine
	Comment               *CommentDef
	AutoIncrementOffset   *uint32
	DefaultCharset        *string
	Collation             *string
	OnCommit              *OnCommit
	OnCluster             *Ident
	PrimaryKey            *Expr
	OrderBy               *OneOrManyWithParens[Expr]
	PartitionBy           *Expr
	ClusterBy             *WrappedCollection[[]Ident]
	ClusteredBy           *ClusteredBy
	Options               *[]SqlOption
	Strict                bool
	CopyGrants            bool
	EnableSchemaEvolution *bool
	ChangeTracking        *bool
	DataRetentionDays     *uint64
	MaxDataExtensionDays  *uint64
	DefaultDDLCollation   *string
	AggregationPolicy     *ObjectName
	RowAccessPolicy       *RowAccessPolicy
	Tags                  *[]Tag
	BaseLocation          *string
	ExternalVolume        *string
	Catalog               *string
	CatalogSync           *string
	SerializationPolicy   *StorageSerializationPolicy
}

CreateTableBuilder helps in building and accessing a create table statement with more ease. Example:

builder := NewCreateTableBuilder(ObjectName{Idents: []Ident{{Value: "table_name"}}}).
    SetIfNotExists(true).
    SetColumns([]ColumnDef{{
        Name:     Ident{Value: "c1"},
        DataType: &DataType{Variant: &Int32Type{}},
    }})

func FromStatement(stmt *StatementImpl) (*CreateTableBuilder, error)

func NewCreateTableBuilder(name ObjectName) *CreateTableBuilder

func (b *CreateTableBuilder) Build() *StatementImpl

func (b *CreateTableBuilder) SetAggregationPolicy(v *ObjectName) *CreateTableBuilder

func (b *CreateTableBuilder) SetAutoIncrementOffset(v *uint32) *CreateTableBuilder

func (b *CreateTableBuilder) SetBaseLocation(v *string) *CreateTableBuilder

func (b *CreateTableBuilder) SetCatalog(v *string) *CreateTableBuilder

func (b *CreateTableBuilder) SetCatalogSync(v *string) *CreateTableBuilder

func (b *CreateTableBuilder) SetChangeTracking(v *bool) *CreateTableBuilder

func (b *CreateTableBuilder) SetClone(v *ObjectName) *CreateTableBuilder

func (b *CreateTableBuilder) SetClusterBy(v *WrappedCollection[[]Ident]) *CreateTableBuilder

func (b *CreateTableBuilder) SetClusteredBy(v *ClusteredBy) *CreateTableBuilder

func (b *CreateTableBuilder) SetCollation(v *string) *CreateTableBuilder

func (b *CreateTableBuilder) SetColumns(v []ColumnDef) *CreateTableBuilder

func (b *CreateTableBuilder) SetComment(v *CommentDef) *CreateTableBuilder

func (b *CreateTableBuilder) SetConstraints(v []TableConstraint) *CreateTableBuilder

func (b *CreateTableBuilder) SetCopyGrants(v bool) *CreateTableBuilder

func (b *CreateTableBuilder) SetDataRetentionDays(v *uint64) *CreateTableBuilder

func (b *CreateTableBuilder) SetDefaultCharset(v *string) *CreateTableBuilder

func (b *CreateTableBuilder) SetDefaultDDLCollation(v *string) *CreateTableBuilder

func (b *CreateTableBuilder) SetEnableSchemaEvolution(v *bool) *CreateTableBuilder

func (b *CreateTableBuilder) SetEngine(v *TableEngine) *CreateTableBuilder

func (b *CreateTableBuilder) SetExternal(v bool) *CreateTableBuilder

func (b *CreateTableBuilder) SetExternalVolume(v *string) *CreateTableBuilder

func (b *CreateTableBuilder) SetFileFormat(v *FileFormat) *CreateTableBuilder

func (b *CreateTableBuilder) SetGlobal(v *bool) *CreateTableBuilder

func (b *CreateTableBuilder) SetHiveDistribution(v HiveDistributionStyle) *CreateTableBuilder

func (b *CreateTableBuilder) SetHiveFormats(v *HiveFormat) *CreateTableBuilder

func (b *CreateTableBuilder) SetIceberg(v bool) *CreateTableBuilder

func (b *CreateTableBuilder) SetIfNotExists(v bool) *CreateTableBuilder

func (b *CreateTableBuilder) SetLike(v *ObjectName) *CreateTableBuilder

func (b *CreateTableBuilder) SetLocation(v *string) *CreateTableBuilder

func (b *CreateTableBuilder) SetMaxDataExtensionDays(v *uint64) *CreateTableBuilder

func (b *CreateTableBuilder) SetOnCluster(v *Ident) *CreateTableBuilder

func (b *CreateTableBuilder) SetOnCommit(v *OnCommit) *CreateTableBuilder

func (b *CreateTableBuilder) SetOptions(v *[]SqlOption) *CreateTableBuilder

func (b *CreateTableBuilder) SetOrReplace(v bool) *CreateTableBuilder

func (b *CreateTableBuilder) SetOrderBy(v *OneOrManyWithParens[Expr]) *CreateTableBuilder

func (b *CreateTableBuilder) SetPartitionBy(v *Expr) *CreateTableBuilder

func (b *CreateTableBuilder) SetPrimaryKey(v *Expr) *CreateTableBuilder

func (b *CreateTableBuilder) SetQuery(v *Query) *CreateTableBuilder

func (b *CreateTableBuilder) SetRowAccessPolicy(v *RowAccessPolicy) *CreateTableBuilder

func (b *CreateTableBuilder) SetSerializationPolicy(v *StorageSerializationPolicy) *CreateTableBuilder

func (b *CreateTableBuilder) SetStrict(v bool) *CreateTableBuilder

func (b *CreateTableBuilder) SetTableProperties(v []SqlOption) *CreateTableBuilder

func (b *CreateTableBuilder) SetTags(v *[]Tag) *CreateTableBuilder

func (b *CreateTableBuilder) SetTemporary(v bool) *CreateTableBuilder

func (b *CreateTableBuilder) SetTransient(v bool) *CreateTableBuilder

func (b *CreateTableBuilder) SetVolatile(v bool) *CreateTableBuilder

func (b *CreateTableBuilder) SetWithOptions(v []SqlOption) *CreateTableBuilder

func (b *CreateTableBuilder) SetWithoutRowID(v bool) *CreateTableBuilder

type CreateTableStatement ¶

type CreateTableStatement struct {
	IfNotExists bool
	Temporary   bool
	Name        string
	Columns     []ColumnDef
	Constraints []TableConstraint
	Inherits    []string
	PartitionBy *PartitionBy
	Options     []TableOption
}

CreateTableStatement represents a CREATE TABLE statement

func (c CreateTableStatement) Children() []Node

func (c CreateTableStatement) TokenLiteral() string

type CustomBinaryOperator ¶

type CustomBinaryOperator struct {
	Parts []string
}

CustomBinaryOperator represents a custom binary operator (PostgreSQL-specific)

func (op *CustomBinaryOperator) String() string

type CustomType ¶

type CustomType struct {
	Name      ObjectName
	Modifiers []string
}

Basic data types

func (t *CustomType) String() string

type DataLoadingOption ¶

type DataLoadingOption struct {
	OptionName string
	OptionType DataLoadingOptionType
	Value      string
}

DataLoadingOption represents a single data loading option

func NewBooleanOption(name string, value bool) DataLoadingOption

func NewEnumOption(name, value string) DataLoadingOption

func NewNumberOption(name string, value interface{}) DataLoadingOption

func NewStringOption(name, value string) DataLoadingOption

func (d *DataLoadingOption) String() string

type DataLoadingOptionType ¶

type DataLoadingOptionType int

DataLoadingOptionType represents the type of a data loading option

const (
	DataLoadingOptionTypeString DataLoadingOptionType = iota
	DataLoadingOptionTypeBoolean
	DataLoadingOptionTypeEnum
	DataLoadingOptionTypeNumber
)

type DataLoadingOptions ¶

type DataLoadingOptions struct {
	Options []DataLoadingOption
}

DataLoadingOptions represents a collection of data loading options

func (d *DataLoadingOptions) String() string

type DataType ¶

type DataType struct {
	Type DataTypeVariant
}

DataType represents SQL data types

type DataTypeVariant ¶

type DataTypeVariant interface {
	fmt.Stringer
	// contains filtered or unexported methods
}

DataTypeVariant represents the different variants of SQL data types

type DateTimeField ¶

type DateTimeField int

DateTimeField represents date/time fields that can be extracted or used in operations

const (
	Year DateTimeField = iota
	Years
	Month
	Months
	Week
	Weeks
	Day
	DayOfWeek
	DayOfYear
	Days
	Date
	Datetime
	Hour
	Hours
	Minute
	Minutes
	Second
	Seconds
	Century
	Decade
	Dow
	Doy
	Epoch
	Isodow
	IsoWeek
	Isoyear
	Julian
	Microsecond
	Microseconds
	Millenium
	Millennium
	Millisecond
	Milliseconds
	Nanosecond
	Nanoseconds
	Quarter
	Time
	Timezone
	TimezoneAbbr
	TimezoneHour
	TimezoneMinute
	TimezoneRegion
	NoDateTime
	CustomDateTime
)

func (d DateTimeField) String() string

type DateType ¶

type DateType struct{}

Basic data types

func (*DateType) String() string

type Delete ¶

type Delete struct {
	Table           TableReference
	Where           Expression
	ReturningClause []Expression
}

Delete represents a DELETE statement

func (d Delete) Children() []Node

func (d Delete) TokenLiteral() string

type DeleteStatement ¶

type DeleteStatement struct {
	With      *WithClause
	TableName string
	Alias     string
	Using     []TableReference
	Where     Expression
	Returning []Expression
}

DeleteStatement represents a DELETE SQL statement

func GetDeleteStatement() *DeleteStatement

func (d DeleteStatement) Children() []Node

func (d *DeleteStatement) Span() models.Span

func (d DeleteStatement) TokenLiteral() string

type DollarQuotedString ¶

type DollarQuotedString struct {
	Value string
	Tag   string
}

DollarQuotedString represents a dollar-quoted string with an optional tag

type DropBehavior ¶

type DropBehavior int

DropBehavior specifies the behavior when dropping objects

const (
	DropCascade DropBehavior = iota
	DropRestrict
)

type EnumMember ¶

type EnumMember struct {
	Name  string
	Value Expression
}

EnumMember represents a member of an ENUM type

func (e *EnumMember) String() string

type EnumType ¶

type EnumType struct {
	Values []EnumMember
	Bits   *uint8
}

Basic data types

func (t *EnumType) String() string

type ExactNumberInfo ¶

type ExactNumberInfo struct {
	Precision *uint64
	Scale     *uint64
}

ExactNumberInfo represents precision and scale information

func (e *ExactNumberInfo) String() string

type ExistsExpression ¶

type ExistsExpression struct {
	Subquery Statement
}

ExistsExpression represents EXISTS (subquery)

func (e ExistsExpression) Children() []Node

func (e ExistsExpression) TokenLiteral() string

type Expr ¶

type Expr interface {
	Node
	// contains filtered or unexported methods
}

Expr represents a SQL expression

type Expression ¶

type Expression interface {
	Node
	// contains filtered or unexported methods
}

Expression represents a SQL expression

type ExtractExpression ¶

type ExtractExpression struct {
	Field  string
	Source Expression
}

ExtractExpression represents EXTRACT(field FROM source)

func (e ExtractExpression) Children() []Node

func (e ExtractExpression) TokenLiteral() string

type FileFormat ¶

type FileFormat int

FileFormat represents file format specifications

const (
	FileFormatNone FileFormat = iota
	FileFormatCSV
	FileFormatJSON
	FileFormatParquet
)

type FileStagingCommand ¶

type FileStagingCommand struct {
	Stage   ObjectName
	Pattern *string
}

FileStagingCommand represents a file staging command

func (f *FileStagingCommand) String() string

type FloatType ¶

type FloatType struct {
	Length *uint64
}

Basic data types

func (t *FloatType) String() string

type FunctionCall ¶

type FunctionCall struct {
	Name      string
	Arguments []Expression // Renamed from Args for consistency
	Over      *WindowSpec  // For window functions
	Distinct  bool
	Filter    Expression // WHERE clause for aggregate functions
}

FunctionCall represents a function call expression

func (f FunctionCall) Children() []Node

func (e *FunctionCall) Span() models.Span

func (f FunctionCall) TokenLiteral() string

type FunctionDesc ¶

type FunctionDesc struct {
	Name      ObjectName
	Schema    string // Optional schema qualifier
	Arguments []string
}

FunctionDesc represents a function descriptor used in SQL statements

func (f FunctionDesc) Children() []Node

func (f FunctionDesc) String() string

func (f FunctionDesc) TokenLiteral() string

type HiveDistributionStyle ¶

type HiveDistributionStyle int

HiveDistributionStyle represents Hive-specific distribution styles

const (
	HiveDistributionNone HiveDistributionStyle = iota
	HiveDistributionHash
	HiveDistributionRandom
)

type HiveFormat ¶

type HiveFormat int

HiveFormat represents Hive-specific storage formats

const (
	HiveFormatNone HiveFormat = iota
	HiveFormatORC
	HiveFormatParquet
	HiveFormatAvro
)

type Ident ¶

type Ident struct {
	Name string
}

Ident represents an identifier in SQL (table name, column name, etc.)

func (i *Ident) Children() []Node

func (i *Ident) String() string

func (i *Ident) TokenLiteral() string

type Identifier ¶

type Identifier struct {
	Name  string
	Table string // Optional table qualifier
}

Identifier represents a column or table name

func GetIdentifier() *Identifier

func (i Identifier) Children() []Node

func (i Identifier) TokenLiteral() string

type InExpression ¶

type InExpression struct {
	Expr Expression
	List []Expression
	Not  bool
}

InExpression represents expr IN (values)

func (i InExpression) Children() []Node

func (i InExpression) TokenLiteral() string

type IndexColumn ¶

type IndexColumn struct {
	Column    string
	Collate   string
	Direction string // ASC, DESC
	NullsLast bool
}

IndexColumn represents a column in an index definition

func (i IndexColumn) Children() []Node

func (i IndexColumn) TokenLiteral() string

type IndexOption ¶

type IndexOption struct {
	Type    IndexOptionType
	Using   *IndexType // Used for Using
	Comment string     // Used for Comment
}

IndexOption represents MySQL index options

func (opt *IndexOption) String() string

type IndexOptionType ¶

type IndexOptionType int

const (
	UsingIndex IndexOptionType = iota
	CommentIndex
)

type IndexType ¶

type IndexType int

IndexType represents the indexing method used by an index

const (
	BTree IndexType = iota
	Hash
)

func (t IndexType) String() string

type InputFormatClause ¶

type InputFormatClause struct {
	Format  string
	Options map[string]string
}

InputFormatClause represents the format specification for input data

type Insert ¶

type Insert struct {
	Table           TableReference
	Columns         []Expression
	Values          [][]Expression
	ReturningClause []Expression
}

Insert represents an INSERT statement

func (i Insert) Children() []Node

func (i Insert) TokenLiteral() string

type InsertStatement ¶

type InsertStatement struct {
	With       *WithClause
	TableName  string
	Columns    []Expression
	Values     []Expression
	Query      *SelectStatement // For INSERT ... SELECT
	Returning  []Expression
	OnConflict *OnConflict
}

InsertStatement represents an INSERT SQL statement

func GetInsertStatement() *InsertStatement

func (i InsertStatement) Children() []Node

func (i *InsertStatement) Span() models.Span

func (i InsertStatement) TokenLiteral() string

type Inspector ¶

type Inspector func(Node) bool

Inspector represents an AST visitor that can be used to traverse an AST and invoke a custom function for each node.

func (f Inspector) Visit(node Node) (Visitor, error)

type IntegerType ¶

type IntegerType struct {
	Length   *uint64
	Unsigned bool
}

Basic data types

func (t *IntegerType) String() string

type JoinClause ¶

type JoinClause struct {
	Type      string // INNER, LEFT, RIGHT, FULL
	Left      TableReference
	Right     TableReference
	Condition Expression
}

JoinClause represents a JOIN clause in SQL

func (j JoinClause) Children() []Node

func (j JoinClause) TokenLiteral() string

type JsonType ¶

type JsonType struct{}

Basic data types

func (*JsonType) String() string

type ListExpression ¶

type ListExpression struct {
	Values []Expression
}

ListExpression represents a list of expressions (1, 2, 3)

func (l ListExpression) Children() []Node

func (l ListExpression) TokenLiteral() string

type LiteralValue ¶

type LiteralValue struct {
	Value interface{}
	Type  string // INTEGER, FLOAT, STRING, BOOLEAN, NULL, etc.
}

LiteralValue represents a literal value in SQL

func GetLiteralValue() *LiteralValue

func (l LiteralValue) Children() []Node

func (l LiteralValue) TokenLiteral() string

type Location ¶

type Location struct {
	Line   int
	Column int
}

Location represents a source location

func (l Location) String() string

type Node ¶

type Node interface {
	TokenLiteral() string
	Children() []Node
}

Node represents any node in the AST

type NormalizationForm ¶

type NormalizationForm int

NormalizationForm represents Unicode normalization forms

const (
	NFC NormalizationForm = iota
	NFD
	NFKC
	NFKD
)

func (n NormalizationForm) String() string

type NullsDistinctOption ¶

type NullsDistinctOption int

NullsDistinctOption represents Postgres unique index nulls handling

const (
	NullsDistinctNone NullsDistinctOption = iota
	NullsDistinct
	NullsNotDistinct
)

func (opt NullsDistinctOption) String() string

type Number ¶

type Number struct {
	Value string
	Long  bool
}

Number represents a numeric value with a flag indicating if it's a long

type NumericType ¶

type NumericType struct {
	Info *ExactNumberInfo
}

Basic data types

func (t *NumericType) String() string

type ObjectName ¶

type ObjectName struct {
	Name string
}

ObjectName represents a qualified or unqualified object name

func (o ObjectName) Children() []Node

func (o ObjectName) String() string

func (o ObjectName) TokenLiteral() string

type OnCommit ¶

type OnCommit int

OnCommit represents the ON COMMIT behavior for temporary tables

const (
	OnCommitNone OnCommit = iota
	OnCommitDelete
	OnCommitPreserve
)

type OnConflict ¶

type OnConflict struct {
	Target     []Expression // Target columns
	Constraint string       // Optional constraint name
	Action     OnConflictAction
}

OnConflict represents ON CONFLICT DO UPDATE/NOTHING clause

func (o OnConflict) Children() []Node

func (o OnConflict) TokenLiteral() string

type OnConflictAction ¶

type OnConflictAction struct {
	DoNothing bool
	DoUpdate  []UpdateExpression
	Where     Expression
}

OnConflictAction represents DO UPDATE/NOTHING in ON CONFLICT clause

type OneOrManyWithParens ¶

type OneOrManyWithParens[T any] struct {
	Items []T
}

OneOrManyWithParens represents a list of items enclosed in parentheses

func (o *OneOrManyWithParens[T]) Children() []Node

func (o *OneOrManyWithParens[T]) TokenLiteral() string

type Partition ¶

type Partition struct {
	Name    string
	Columns []*Ident
}

Partition represents table partitioning information

type PartitionBy ¶

type PartitionBy struct {
	Type     string // RANGE, LIST, HASH
	Columns  []string
	Boundary []Expression
}

PartitionBy represents a PARTITION BY clause

func (p PartitionBy) Children() []Node

func (p PartitionBy) TokenLiteral() string

type PositionExpression ¶

type PositionExpression struct {
	Substr Expression
	Str    Expression
}

PositionExpression represents POSITION(substr IN str)

func (p PositionExpression) Children() []Node

func (p PositionExpression) TokenLiteral() string

type Query ¶

type Query struct {
	Text string
}

Query represents a SQL query

func (q *Query) Children() []Node

func (q *Query) TokenLiteral() string

type ReferenceDefinition ¶

type ReferenceDefinition struct {
	Table    string
	Columns  []string
	OnDelete string
	OnUpdate string
	Match    string
}

ReferenceDefinition represents a REFERENCES clause

func (r ReferenceDefinition) Children() []Node

func (r *ReferenceDefinition) String() string

func (r ReferenceDefinition) TokenLiteral() string

type RoleOption ¶

type RoleOption struct {
	Name  string
	Type  RoleOptionType
	Value interface{} // Can be bool or Expression depending on Type
}

RoleOption represents an option in ROLE statement

func (opt *RoleOption) String() string

type RoleOptionType ¶

type RoleOptionType int

const (
	BypassRLS RoleOptionType = iota
	ConnectionLimit
	CreateDB
	CreateRole
	Inherit
	Login
	Password
	Replication
	SuperUser
	ValidUntil
)

type RowAccessPolicy ¶

type RowAccessPolicy struct {
	Name    string
	Filter  Expr
	Enabled bool
}

RowAccessPolicy represents row-level access policy

func (r *RowAccessPolicy) Children() []Node

func (r *RowAccessPolicy) TokenLiteral() string

type Select ¶

type Select struct {
	Distinct bool
	Columns  []Expression
	From     []TableReference
	Where    Expression
	GroupBy  []Expression
	Having   Expression
	OrderBy  []Expression
	Limit    *int64
	Offset   *int64
}

Select represents a SELECT statement

func (s Select) Children() []Node

func (s Select) TokenLiteral() string

type SelectStatement ¶

type SelectStatement struct {
	With      *WithClause
	Distinct  bool
	Columns   []Expression
	From      []TableReference
	TableName string // Added for pool operations
	Joins     []JoinClause
	Where     Expression
	GroupBy   []Expression
	Having    Expression
	Windows   []WindowSpec
	OrderBy   []Expression
	Limit     *int
	Offset    *int
}

SelectStatement represents a SELECT SQL statement

func GetSelectStatement() *SelectStatement

func (s SelectStatement) Children() []Node

func (s *SelectStatement) Span() models.Span

func (s SelectStatement) TokenLiteral() string

type SetOperation ¶

type SetOperation struct {
	Left     Statement
	Operator string // UNION, EXCEPT, INTERSECT
	Right    Statement
	All      bool // UNION ALL vs UNION
}

SetOperation represents set operations (UNION, EXCEPT, INTERSECT) between two statements. It supports the ALL modifier (e.g., UNION ALL) and proper left-associative parsing. Phase 2 Complete: Full parser support with left-associative precedence.

func (s SetOperation) Children() []Node

func (s SetOperation) TokenLiteral() string

type SetType ¶

type SetType struct {
	Values []string
}

Basic data types

func (t *SetType) String() string

type Setting ¶

type Setting struct {
	Column *Ident
	Value  Expression
}

Setting represents a SET clause in an UPDATE statement

type Span ¶

type Span struct {
	Start Location
	End   Location
}

Span represents a source location span

func (s Span) String() string

type Spanned ¶

type Spanned interface {
	// Span returns the source location span for this node
	Span() models.Span
}

Spanned represents an AST node that has source location information

type SpannedNode ¶

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

SpannedNode represents a basic AST node with source location information

func (n *SpannedNode) SetSpan(span models.Span)

func (n *SpannedNode) Span() models.Span

type SqlOption ¶

type SqlOption struct {
	Name  string
	Value string
}

SqlOption represents SQL-specific options

type StageLoadSelectItem ¶

type StageLoadSelectItem struct {
	Alias      *Ident
	FileColNum int32
	Element    *Ident
	ItemAs     *Ident
}

StageLoadSelectItem represents a select item in stage loading operations

func (s *StageLoadSelectItem) String() string

type StageParamsObject ¶

type StageParamsObject struct {
	URL                *string
	Encryption         DataLoadingOptions
	Endpoint           *string
	StorageIntegration *string
	Credentials        DataLoadingOptions
}

StageParamsObject represents parameters for stage operations in data loading

func (s *StageParamsObject) String() string

type Statement ¶

type Statement interface {
	Node
	// contains filtered or unexported methods
}

Statement represents a SQL statement

type StatementImpl ¶

type StatementImpl struct {
	Variant StatementVariant
}

StatementImpl represents a concrete implementation of a SQL statement

func (s *StatementImpl) Children() []Node

func (s *StatementImpl) TokenLiteral() string

type StatementVariant ¶

type StatementVariant interface {
	Node
	// contains filtered or unexported methods
}

StatementVariant represents a specific type of SQL statement

type StorageSerializationPolicy ¶

type StorageSerializationPolicy int

StorageSerializationPolicy represents storage serialization policy

const (
	StorageSerializationNone StorageSerializationPolicy = iota
	StorageSerializationJSON
	StorageSerializationAvro
)

type StructBracketKind ¶

type StructBracketKind int

StructBracketKind represents the type of brackets used in STRUCT type

const (
	ParenthesesBrackets StructBracketKind = iota
	AngleBracketsBrackets
)

type StructField ¶

type StructField struct {
	Name string
	Type string
	Tags map[string]string
}

StructField represents a field in a struct type

func GetStructFields(t reflect.Type) []StructField

type SubstringExpression ¶

type SubstringExpression struct {
	Str    Expression
	Start  Expression
	Length Expression
}

SubstringExpression represents SUBSTRING(str FROM start [FOR length])

func (s SubstringExpression) Children() []Node

func (s SubstringExpression) TokenLiteral() string

type Table ¶

type Table struct {
	Name        string
	Columns     []*ColumnDef
	Constraints []*TableConstraint
	Options     map[string]string
}

Table represents a table definition

type TableConstraint ¶

type TableConstraint struct {
	Name       string
	Type       string // PRIMARY KEY, UNIQUE, FOREIGN KEY, CHECK
	Columns    []string
	References *ReferenceDefinition
	Check      Expression
}

TableConstraint represents a table constraint

func (t TableConstraint) Children() []Node

func (t TableConstraint) TokenLiteral() string

type TableEngine ¶

type TableEngine string

TableEngine represents the storage engine for a table

type TableOption ¶

type TableOption struct {
	Name  string
	Value string
}

TableOption represents table options like ENGINE, CHARSET, etc.

func (t TableOption) Children() []Node

func (t TableOption) TokenLiteral() string

type TableReference ¶

type TableReference struct {
	Name  string
	Alias string
}

TableReference represents a table in FROM clause

func (t TableReference) Children() []Node

func (t TableReference) TokenLiteral() string

type TableType ¶

type TableType struct {
	Columns []*ColumnDef
}

Basic data types

func (t *TableType) String() string

type Tag ¶

type Tag struct {
	Key   string
	Value string
}

Tag represents a key-value metadata tag

type TimeType ¶

type TimeType struct {
	Precision *uint64
	Timezone  TimezoneInfo
}

Basic data types

func (t *TimeType) String() string

type TimestampType ¶

type TimestampType struct {
	Precision *uint64
	Timezone  TimezoneInfo
}

Basic data types

func (t *TimestampType) String() string

type TimezoneInfo ¶

type TimezoneInfo int

TimezoneInfo represents timezone information for temporal types

const (
	NoTimezone TimezoneInfo = iota
	WithTimeZone
	WithoutTimeZone
	Tz
)

func (t TimezoneInfo) String() string

type Token ¶

type Token struct {
	Type TokenType
}

Token represents a lexical token

func (t Token) String() string

type TokenType ¶

type TokenType int

TokenType represents the type of a token

const (
	EOF TokenType = iota
	Comma
	Period
)

type TokenWithSpan ¶

type TokenWithSpan struct {
	Token Token
	Span  Span
}

TokenWithSpan represents a token with its source location span

func NewTokenWithSpan(token Token, span Span) TokenWithSpan

func NewTokenWithSpanEOF() TokenWithSpan

func (t TokenWithSpan) GoString() string

func (t TokenWithSpan) String() string

type TriggerEvent ¶

type TriggerEvent struct {
	Type    TriggerEventType
	Columns []Identifier // Only used for UPDATE events
}

TriggerEvent describes trigger events

func (t TriggerEvent) Children() []Node

func (t TriggerEvent) String() string

func (t TriggerEvent) TokenLiteral() string

type TriggerEventType ¶

type TriggerEventType int

const (
	TriggerEventInsert TriggerEventType = iota
	TriggerEventUpdate
	TriggerEventDelete
	TriggerEventTruncate
)

type TriggerExecBody ¶

type TriggerExecBody struct {
	ExecType TriggerExecBodyType
	FuncDesc FunctionDesc
}

TriggerExecBody represents the execution body of a trigger

func (t TriggerExecBody) Children() []Node

func (t TriggerExecBody) String() string

func (t TriggerExecBody) TokenLiteral() string

type TriggerExecBodyType ¶

type TriggerExecBodyType int

TriggerExecBodyType represents types of trigger body execution

const (
	TriggerExecBodyFunction TriggerExecBodyType = iota
	TriggerExecBodyProcedure
)

func (t TriggerExecBodyType) String() string

type TriggerObject ¶

type TriggerObject int

TriggerObject specifies whether the trigger function should be fired once for every row affected by the trigger event, or just once per SQL statement.

const (
	TriggerObjectRow TriggerObject = iota
	TriggerObjectStatement
)

func (t TriggerObject) Children() []Node

func (t TriggerObject) String() string

func (t TriggerObject) TokenLiteral() string

type TriggerPeriod ¶

type TriggerPeriod int

TriggerPeriod represents when the trigger should be executed

const (
	TriggerPeriodAfter TriggerPeriod = iota
	TriggerPeriodBefore
	TriggerPeriodInsteadOf
)

func (t TriggerPeriod) Children() []Node

func (t TriggerPeriod) String() string

func (t TriggerPeriod) TokenLiteral() string

type TriggerReferencing ¶

type TriggerReferencing struct {
	ReferType              TriggerReferencingType
	IsAs                   bool
	TransitionRelationName ObjectName
}

TriggerReferencing represents a declaration of relation names that provide access to the transition relations of the triggering statement

func (t TriggerReferencing) Children() []Node

func (t TriggerReferencing) String() string

func (t TriggerReferencing) TokenLiteral() string

type TriggerReferencingType ¶

type TriggerReferencingType int

TriggerReferencingType indicates whether the following relation name is for the before-image transition relation or the after-image transition relation

const (
	TriggerReferencingOldTable TriggerReferencingType = iota
	TriggerReferencingNewTable
)

func (t TriggerReferencingType) String() string

type TrimWhereField ¶

type TrimWhereField int

TrimWhereField represents the type of trimming operation

const (
	Both TrimWhereField = iota
	Leading
	Trailing
)

func (t TrimWhereField) String() string

type UnaryExpression ¶

type UnaryExpression struct {
	Operator UnaryOperator
	Expr     Expression
}

UnaryExpression represents operations like NOT expr

func (u UnaryExpression) Children() []Node

func (e *UnaryExpression) Span() models.Span

func (u *UnaryExpression) TokenLiteral() string

type UnaryOperator ¶

type UnaryOperator int

UnaryOperator represents unary operators in SQL expressions

const (
	// Plus represents unary plus operator, e.g. +9
	Plus UnaryOperator = iota
	// Minus represents unary minus operator, e.g. -9
	Minus
	// Not represents logical NOT operator, e.g. NOT(true)
	Not
	// PGBitwiseNot represents PostgreSQL bitwise NOT operator, e.g. ~9
	PGBitwiseNot
	// PGSquareRoot represents PostgreSQL square root operator, e.g. |/9
	PGSquareRoot
	// PGCubeRoot represents PostgreSQL cube root operator, e.g. ||/27
	PGCubeRoot
	// PGPostfixFactorial represents PostgreSQL postfix factorial operator, e.g. 9!
	PGPostfixFactorial
	// PGPrefixFactorial represents PostgreSQL prefix factorial operator, e.g. !!9
	PGPrefixFactorial
	// PGAbs represents PostgreSQL absolute value operator, e.g. @ -9
	PGAbs
	// BangNot represents Hive-specific logical NOT operator, e.g. ! false
	BangNot
)

func (op UnaryOperator) String() string

type Update ¶

type Update struct {
	Table           TableReference
	Updates         []UpdateExpression
	Where           Expression
	ReturningClause []Expression
}

Update represents an UPDATE statement

func (u Update) Children() []Node

func (u Update) TokenLiteral() string

type UpdateExpression ¶

type UpdateExpression struct {
	Column Expression
	Value  Expression
}

UpdateExpression represents a column=value expression in UPDATE

func GetUpdateExpression() *UpdateExpression

func (u UpdateExpression) Children() []Node

func (u UpdateExpression) TokenLiteral() string

type UpdateStatement ¶

type UpdateStatement struct {
	With        *WithClause
	TableName   string
	Alias       string
	Updates     []UpdateExpression // Keep for backward compatibility
	Assignments []UpdateExpression // New field for consistency with span.go
	From        []TableReference
	Where       Expression
	Returning   []Expression
}

UpdateStatement represents an UPDATE SQL statement

func GetUpdateStatement() *UpdateStatement

func (u UpdateStatement) Children() []Node

func (u *UpdateStatement) Span() models.Span

func (u UpdateStatement) TokenLiteral() string

type UpsertClause ¶

type UpsertClause struct {
	Updates []UpdateExpression
}

UpsertClause represents INSERT ... ON DUPLICATE KEY UPDATE

func (u UpsertClause) Children() []Node

func (u UpsertClause) TokenLiteral() string

type Value ¶

type Value struct {
	Type  ValueType
	Value interface{}
}

Value represents primitive SQL values such as number and string

func (v Value) Children() []Node

func (v Value) String() string

func (v Value) TokenLiteral() string

type ValueType ¶

type ValueType int

ValueType represents the type of a SQL value

const (
	NumberValue ValueType = iota
	SingleQuotedStringValue
	DollarQuotedStringValue
	TripleSingleQuotedStringValue
	TripleDoubleQuotedStringValue
	EscapedStringLiteralValue
	UnicodeStringLiteralValue
	SingleQuotedByteStringLiteralValue
	DoubleQuotedByteStringLiteralValue
	TripleSingleQuotedByteStringLiteralValue
	TripleDoubleQuotedByteStringLiteralValue
	SingleQuotedRawStringLiteralValue
	DoubleQuotedRawStringLiteralValue
	TripleSingleQuotedRawStringLiteralValue
	TripleDoubleQuotedRawStringLiteralValue
	NationalStringLiteralValue
	HexStringLiteralValue
	DoubleQuotedStringValue
	BooleanValue
	NullValue
	PlaceholderValue
)

type Values ¶

type Values struct {
	Rows [][]Expression
}

Values represents VALUES clause

func (v Values) Children() []Node

func (v Values) TokenLiteral() string

type VarcharType ¶

type VarcharType struct {
	Length *CharacterLength
}

Basic data types

func (t *VarcharType) String() string

type VisitFunc ¶

type VisitFunc func(Node) (Visitor, error)

VisitFunc is a function type that can be used to implement custom visitors without creating a new type.

func (f VisitFunc) Visit(node Node) (Visitor, error)

type Visitor ¶

type Visitor interface {
	Visit(node Node) (w Visitor, err error)
}

Visitor defines an interface for traversing the AST. The Visit method is called for each node encountered by Walk. If the result visitor w is not nil, Walk visits each of the children of node with the visitor w, followed by a call of w.Visit(nil).

type WhenClause ¶

type WhenClause struct {
	Condition Expression
	Result    Expression
}

WhenClause represents WHEN ... THEN ... in CASE expression

func (w WhenClause) Children() []Node

func (w WhenClause) TokenLiteral() string

type WindowFrame ¶

type WindowFrame struct {
	Type  string // ROWS, RANGE
	Start WindowFrameBound
	End   *WindowFrameBound
}

WindowFrame represents window frame clause

func (w WindowFrame) Children() []Node

func (w WindowFrame) TokenLiteral() string

type WindowFrameBound ¶

type WindowFrameBound struct {
	Type  string // CURRENT ROW, UNBOUNDED PRECEDING, etc.
	Value Expression
}

WindowFrameBound represents window frame bound

type WindowSpec ¶

type WindowSpec struct {
	Name        string
	PartitionBy []Expression
	OrderBy     []Expression
	FrameClause *WindowFrame
}

WindowSpec represents a window specification

func (w WindowSpec) Children() []Node

func (w WindowSpec) TokenLiteral() string

type WithClause ¶

type WithClause struct {
	Recursive bool
	CTEs      []*CommonTableExpr
}

WithClause represents a WITH clause in a SQL statement. It supports both simple and recursive Common Table Expressions (CTEs). Phase 2 Complete: Full parser integration with all statement types.

func (w WithClause) Children() []Node

func (w WithClause) TokenLiteral() string

type WrappedCollection ¶

type WrappedCollection[T any] struct {
	Items   []T
	Wrapper string
}

WrappedCollection represents a collection of items with optional wrapper

func (w *WrappedCollection[T]) Children() []Node

func (w *WrappedCollection[T]) TokenLiteral() string