ast

package
v0.0.1-0...-4535bed Latest Latest
Warning

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

 Go to latest Published: Apr 5, 2024 License: PostgreSQL Imports: 5 Imported by: 0

Documentation

Overview

Package ast represents SQL code hierarchy.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func ColumnName 

func ColumnName(n Node) string

ColumnName returns the identifier of a column expression.

e.g. "col0" for "a AS col0", "t1.col0", etc.

func Copy 

func Copy[T Node](n T) T

Copy recursively a node.

Token lists are duplicated, but tokens are not.

func EndLine 

func EndLine[T Node](n T) T

EndLine ensures node ends line.

func Indent 

func Indent[T Node](n T, i string) T

Indent a whole tree.

Replace node indentation with given string. Indentation is recursive. Follows Simon Holywell style guide.

func IndentAfter 

func IndentAfter[T Node](before lexer.Token, n T, i string) (T, lexer.Token)

IndentAfter indent node after a token.

Handle spacing between token and node like parenthesis, new line or regular keyword.

func IndentFrom 

func IndentFrom[T Node](new T, old Node) T

IndentFrom copies indentation from a node to another.

If old does not begins line, indent is removed.

func OneSpace 

func OneSpace[T Node](n T) T

OneSpace prefixes node with a single space.

Use it when moving an expression after a keyword. Removes leading comment.

func SpaceFrom 

func SpaceFrom[T Node](new T, old Node) T

SpaceFrom apply spacings from a node to another.

Preserves whitespace, indentation and comments from old node.

func SpaceFromItem 

func SpaceFromItem[T Node](new T, grouping Grouping, pos int) T

SpaceFromItem apply spacings from an item in a grouping.

It's used when replacing a list with a plain syntax like decode() with CASE. Since comma will be lost, spacings around comma are moved to the new node.

func SwapWhitespaces 

func SwapWhitespaces[T1 Node, T2 Node](first T1, second T2) (T1, T2)

SwapWhitespaces apply spacings from a node to another and vice versa.

Preserves comments. Useful when you swap two nodes.

func TableName 

func TableName(expr Node) string

TableName guess table expression name in FROM clause.

Accepts <table>, schema.<table> and expr AS <table>, ... JOIN <table>.

func TrimNewLine 

func TrimNewLine[T Node](n T) T

TrimNewLine removes final new line from node.

Use it when wrapping a node in another.

Types

type Alias 

type Alias struct {
	Expression Node
	// As may be Void if AS keyword is omitted.
	As lexer.Token
	// Name is the new name, an identifier.
	Name lexer.Token
}

Alias renames an expression with or without AS keyword.

func AliasTo 

func AliasTo(expr Node, name string) Alias

AliasTo ensure expr has a name.

If expr is an alias, it renames it. If expr is not an alias, it creates a new alias with the given name.

func (Alias) String 

func (a Alias) String() string

func (Alias) Tokens 

func (a Alias) Tokens() []lexer.Token

func (Alias) TransformEnd 

func (a Alias) TransformEnd(f Transformer[lexer.Token]) Node

func (Alias) TransformStart 

func (a Alias) TransformStart(f Transformer[lexer.Token]) Node

func (Alias) Visit 

func (a Alias) Visit(f Transformer[Node]) Node

type Between 

type Between struct {
	Expression Node
	Between    []lexer.Token
	Start      Node
	And        lexer.Token
	End        Node
}

Between holds BETWEEN or NOT BETWEEN expression.

func (Between) Tokens 

func (b Between) Tokens() []lexer.Token

func (Between) TransformEnd 

func (b Between) TransformEnd(f Transformer[lexer.Token]) Node

func (Between) TransformStart 

func (b Between) TransformStart(f Transformer[lexer.Token]) Node

func (Between) Visit 

func (b Between) Visit(f Transformer[Node]) Node

type CTE 

type CTE struct {
	Name         lexer.Token
	Columns      Columns // May be zero.
	As           lexer.Token
	Materialized []lexer.Token // May be nil
	Open         lexer.Token
	Query        Node
	Close        lexer.Token
	Search       Node        // May be nil
	Cycle        Node        // May be nil
	Comma        lexer.Token // May be zero
}

CTE holds a single Common Table Expression.

Example: 

cte_name [( column_name [, ...] )]
AS ( query )
[SEARCH]
[CYCLE]

Holds the final comma separing from the next CTE.

cf. https://www.postgresql.org/docs/current/queries-with.html#QUERIES-WITH

func (CTE) Tokens 

func (c CTE) Tokens() []lexer.Token

func (CTE) TransformEnd 

func (c CTE) TransformEnd(f Transformer[lexer.Token]) Node

func (CTE) TransformStart 

func (c CTE) TransformStart(f Transformer[lexer.Token]) Node

func (CTE) Visit 

func (c CTE) Visit(f Transformer[Node]) Node

type Call 

type Call struct {
	Function Node     // Identifier or qualified name
	Args     Grouping // The grouping containing arguments
}

Call holds a function call.

func (Call) In 

func (c Call) In(s ...string) bool

In reports whether function name is in the given list of strings.

func (Call) Is 

func (c Call) Is(s ...string) bool

Is reports whether the function name matches the given strings.

Accepts one or two strings. If two strings are given, the first one is the package/schema name and the second one is the function name.

func (Call) Tokens 

func (c Call) Tokens() []lexer.Token

func (Call) TransformEnd 

func (c Call) TransformEnd(f Transformer[lexer.Token]) Node

func (Call) TransformStart 

func (c Call) TransformStart(f Transformer[lexer.Token]) Node

func (Call) Visit 

func (c Call) Visit(f Transformer[Node]) Node

type Case 

type Case struct {
	Case       lexer.Token
	Expression Node // nil if CASE is used for simple WHEN/THEN.
	Cases      []When
	Else       Prefix // Use Prefix.IsZero() to check for presence of ELSE.
	End        lexer.Token
}

Case is a SQL CASE statement.

func (Case) Tokens 

func (c Case) Tokens() []lexer.Token

func (Case) TransformEnd 

func (c Case) TransformEnd(f Transformer[lexer.Token]) Node

func (Case) TransformStart 

func (c Case) TransformStart(f Transformer[lexer.Token]) Node

func (Case) Visit 

func (c Case) Visit(f Transformer[Node]) Node

type Clause 

type Clause struct {
	Keywords   []lexer.Token
	Expression Node // May be nil
}

Clause holds keywords prefixing an expression.

For example, PARTITION BY, DISTINCT ON, etc.

func (Clause) IsZero 

func (c Clause) IsZero() bool

func (Clause) Tokens 

func (c Clause) Tokens() []lexer.Token

func (Clause) TransformEnd 

func (c Clause) TransformEnd(f Transformer[lexer.Token]) Node

func (Clause) TransformStart 

func (c Clause) TransformStart(f Transformer[lexer.Token]) Node

func (Clause) Visit 

func (c Clause) Visit(f Transformer[Node]) Node

type Column 

type Column struct {
	Name  lexer.Token
	Comma lexer.Token
}

Column is an item in a Columns list.

func (Column) Tokens 

func (c Column) Tokens() []lexer.Token

func (Column) TransformEnd 

func (c Column) TransformEnd(f Transformer[lexer.Token]) Node

func (Column) TransformStart 

func (c Column) TransformStart(f Transformer[lexer.Token]) Node

func (Column) Visit 

func (c Column) Visit(f Transformer[Node]) Node

type Columns 

type Columns struct {
	Open  lexer.Token
	Names []Column
	Close lexer.Token
}

Columns holds a list of columns names.

This is plain column name, without typing like in CREATE TABLE.

Parens can be zero.

func (Columns) IsZero 

func (c Columns) IsZero() bool

func (Columns) Tokens 

func (c Columns) Tokens() []lexer.Token

func (Columns) TransformEnd 

func (c Columns) TransformEnd(f Transformer[lexer.Token]) Node

func (Columns) TransformStart 

func (c Columns) TransformStart(f Transformer[lexer.Token]) Node

func (Columns) Visit 

func (c Columns) Visit(f Transformer[Node]) Node

type ConnectBy 

type ConnectBy struct {
	ConnectBy []lexer.Token
	Condition Node
	StartWith Node
}

ConnectBy holds CONNECT BY clause of SELECT statement.

func (ConnectBy) Tokens 

func (c ConnectBy) Tokens() []lexer.Token

func (ConnectBy) TransformEnd 

func (c ConnectBy) TransformEnd(f Transformer[lexer.Token]) Node

func (ConnectBy) TransformStart 

func (c ConnectBy) TransformStart(f Transformer[lexer.Token]) Node

func (ConnectBy) Visit 

func (c ConnectBy) Visit(f Transformer[Node]) Node

type Cycle 

type Cycle struct {
	Cycle   lexer.Token
	Columns Columns
	Set     lexer.Token
	Target  lexer.Token

	// May be zeros
	To           lexer.Token
	Value        lexer.Token
	Default      lexer.Token
	DefaultValue lexer.Token

	// Required.
	Using lexer.Token
	Path  lexer.Token
}

Cycle holds CYCLE clause of CTE.

func (Cycle) Tokens 

func (c Cycle) Tokens() []lexer.Token

func (Cycle) TransformEnd 

func (c Cycle) TransformEnd(f Transformer[lexer.Token]) Node

func (Cycle) TransformStart 

func (c Cycle) TransformStart(f Transformer[lexer.Token]) Node

func (Cycle) Visit 

func (c Cycle) Visit(f Transformer[Node]) Node

type Fetch 

type Fetch struct {
	Fetch  []lexer.Token // FETCH { FIRST | NEXT }
	Count  Node
	Tail   []lexer.Token //{ ROW | ROWS } { ONLY | WITH TIES }
	Offset Node          // PostgreSQL accepts OFFSET after FETCH
}

Fetch holds FETCH FIRST or FETCH NEXT.

func (Fetch) Tokens 

func (f Fetch) Tokens() []lexer.Token

func (Fetch) TransformEnd 

func (f Fetch) TransformEnd(g Transformer[lexer.Token]) Node

func (Fetch) TransformStart 

func (f Fetch) TransformStart(g Transformer[lexer.Token]) Node

func (Fetch) Visit 

func (f Fetch) Visit(g Transformer[Node]) Node

type From 

type From struct {
	From   lexer.Token
	Tables Grouping
}

From holds the FROM clause of a SELECT query.

func (*From) Append 

func (from *From) Append(table Node)

Append a table expression to FROM clause.

Ensures FROM keyword is set. Indents JOIN with FROM and tables with previous table. Ensures JOIN is on its own line.

func (From) Contains 

func (from From) Contains(table string) bool

Contains checks existence of table expression in FROM.

func (From) Index 

func (from From) Index(table string) int

Index return position of table in FROM or -1.

func (From) IsJoin 

func (from From) IsJoin(table string) bool

IsJoin reports whether a table expression is a JOIN.

table is the name of the table in the FROM clause.

func (From) IsZero 

func (from From) IsZero() bool

func (From) Names 

func (from From) Names() (names []string)

Names of all table expression in FROM clause.

Returns anonymous expression as empty string.

func (*From) Replace 

func (from *From) Replace(table string, expr Node)

Replace a table expression by name.

func (From) Sort 

func (from From) Sort(names ...string) (sorted []string)

Sort table names in the order they appear in FROM clause.

Panics if a name is not in FROM.

func (From) Tokens 

func (from From) Tokens() []lexer.Token

func (From) TransformEnd 

func (from From) TransformEnd(f Transformer[lexer.Token]) Node

func (From) TransformStart 

func (from From) TransformStart(f Transformer[lexer.Token]) Node

func (From) Visit 

func (from From) Visit(f Transformer[Node]) Node

type GroupBy 

type GroupBy struct {
	GroupBy     []lexer.Token // May contains SIBLINGS
	Expressions Grouping
	Having      Node
}

GroupBy holds a GROUP BY clause.

func (GroupBy) Tokens 

func (g GroupBy) Tokens() []lexer.Token

func (GroupBy) TransformEnd 

func (g GroupBy) TransformEnd(f Transformer[lexer.Token]) Node

func (GroupBy) TransformStart 

func (g GroupBy) TransformStart(f Transformer[lexer.Token]) Node

func (GroupBy) Visit 

func (g GroupBy) Visit(f Transformer[Node]) Node

type Grouping 

type Grouping struct {
	Open  lexer.Token
	Items []Postfix
	Close lexer.Token
}

Grouping holds comma separated expressions, eventually braced by parenthesis.

e.g. a.id, a.name or (1, 2) or [3, 4]

Open and Close can be Void for SELECT list, FROM clause. All Items are Postfix node with separator as postfix operator. Last Item has void operator because SQL does not allow trailing comma.

Used for function call arguments, sub-queries, function signature, etc.

func (*Grouping) Append 

func (g *Grouping) Append(n Node)

Append adds a new item to the grouping.

Ensure a comma between items.

func (*Grouping) Delete 

func (g *Grouping) Delete(pos int) (expr Node)

Delete removes an item at position.

func (*Grouping) Insert 

func (g *Grouping) Insert(pos int, n Node)

Insert adds a new item to the grouping at the given position.

Panics if position is out of range.

func (Grouping) Tokens 

func (g Grouping) Tokens() []lexer.Token

func (Grouping) TransformEnd 

func (g Grouping) TransformEnd(f Transformer[lexer.Token]) Node

func (Grouping) TransformStart 

func (g Grouping) TransformStart(f Transformer[lexer.Token]) Node

func (Grouping) Visit 

func (g Grouping) Visit(f Transformer[Node]) Node

type Having 

type Having struct {
	Having    lexer.Token
	Condition Node
	// Oracle accepts HAVING before GROUP BY.
	// See. https://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_10002.htm#i2065777
	GroupBy Node
}

Having holds a HAVING SQL statement.

func (Having) Tokens 

func (h Having) Tokens() []lexer.Token

func (Having) TransformEnd 

func (h Having) TransformEnd(f Transformer[lexer.Token]) Node

func (Having) TransformStart 

func (h Having) TransformStart(f Transformer[lexer.Token]) Node

func (Having) Visit 

func (h Having) Visit(f Transformer[Node]) Node

type Infix 

type Infix struct {
	Left  Node
	Op    []lexer.Token
	Right Node
}

Infix is a node with an operator with left and right operands. e.g. 1 + 2, 3 OR 4

func (Infix) Is 

func (i Infix) Is(s ...string) bool

Is reports whether operator of the Infix node matches a list of strings.

func (Infix) Rebalance 

func (i Infix) Rebalance() Node

Rebalance ensure tip of Infix chain of same operator starts with first item. Assumes that Left is the chain of previous items.

func (Infix) Tokens 

func (i Infix) Tokens() []lexer.Token

func (Infix) TransformEnd 

func (i Infix) TransformEnd(f Transformer[lexer.Token]) Node

func (Infix) TransformStart 

func (i Infix) TransformStart(f Transformer[lexer.Token]) Node

func (Infix) Visit 

func (i Infix) Visit(f Transformer[Node]) Node

type Join 

type Join struct {
	// Left table is previous table in From.
	Join      []lexer.Token
	Right     Node // Right table, not join direction.
	Condition Node // nil or an [ast.Where] clause with ON or USING keyword.
}

Join holds an explicit JOIN clause.

func (Join) Tokens 

func (j Join) Tokens() (tokens []lexer.Token)

func (Join) TransformEnd 

func (j Join) TransformEnd(f Transformer[lexer.Token]) Node

func (Join) TransformStart 

func (j Join) TransformStart(f Transformer[lexer.Token]) Node

func (Join) Visit 

func (j Join) Visit(f Transformer[Node]) Node

type Leaf 

type Leaf struct {
	Token lexer.Token
}

Leaf is a single token node without children.

func (Leaf) In 

func (a Leaf) In(s ...any) bool

In reports whether the leaf is any of the given strings.

func (Leaf) IsIdentifier 

func (a Leaf) IsIdentifier() bool

IsIdentifier reports whether the token is an identifier.

func (Leaf) String 

func (a Leaf) String() string

func (Leaf) Tokens 

func (a Leaf) Tokens() []lexer.Token

func (Leaf) TransformEnd 

func (a Leaf) TransformEnd(f Transformer[lexer.Token]) Node

func (Leaf) TransformStart 

func (a Leaf) TransformStart(f Transformer[lexer.Token]) Node

func (Leaf) Visit 

func (a Leaf) Visit(f Transformer[Node]) Node

type Limit 

type Limit struct {
	Limit  lexer.Token
	Count  Node
	Offset Node
}

Limit holds a LIMIT clause.

func (Limit) Tokens 

func (l Limit) Tokens() []lexer.Token

func (Limit) TransformEnd 

func (l Limit) TransformEnd(f Transformer[lexer.Token]) Node

func (Limit) TransformStart 

func (l Limit) TransformStart(f Transformer[lexer.Token]) Node

func (Limit) Visit 

func (l Limit) Visit(f Transformer[Node]) Node

type LiteralCast 

type LiteralCast struct {
	Type    lexer.Token
	Literal lexer.Token
}

LiteralCast is a node with a type and a string literal. e.g. date '2020-01-01' or interval '1 day'

func (LiteralCast) Tokens 

func (c LiteralCast) Tokens() []lexer.Token

func (LiteralCast) TransformEnd 

func (c LiteralCast) TransformEnd(f Transformer[lexer.Token]) Node

func (LiteralCast) TransformStart 

func (c LiteralCast) TransformStart(f Transformer[lexer.Token]) Node

func (LiteralCast) Visit 

func (c LiteralCast) Visit(f Transformer[Node]) Node

type Node 

type Node interface {
	lexer.Tokener
	// Transform first token of the node.
	TransformStart(Transformer[lexer.Token]) Node
	// Transform last token of the node.
	TransformEnd(Transformer[lexer.Token]) Node
	// Depth-first traversal of the AST applying a transformation function.
	// Used to rewrite expressions.
	Visit(Transformer[Node]) Node
}

Node is the base interface for all nodes in the AST.

func TransformColumnRef 

func TransformColumnRef(n Node, f Transformer[Node]) Node

TransformColumnRef applies a transformation to all column names in the WHERE clause.

Node passed to f is guaranteed to be a Leaf with an identifier token or an Infix with qualified column ref.

Example: <col> = 1, <t1.col> = <t2.col>, COALESCE(<column>)

type Offset 

type Offset struct {
	Offset lexer.Token
	Start  Node
	Unit   lexer.Token // ROW or ROWS
	Fetch  Node
}

Offset holds OFFSET clause of LIMIT.

func (Offset) Tokens 

func (o Offset) Tokens() []lexer.Token

func (Offset) TransformEnd 

func (o Offset) TransformEnd(f Transformer[lexer.Token]) Node

func (Offset) TransformStart 

func (o Offset) TransformStart(f Transformer[lexer.Token]) Node

func (Offset) Visit 

func (o Offset) Visit(f Transformer[Node]) Node

type OrderBy 

type OrderBy struct {
	OrderBy  []lexer.Token // May hold SIBLINGS
	Criteria Grouping
}

func (OrderBy) Tokens 

func (o OrderBy) Tokens() []lexer.Token

func (OrderBy) TransformEnd 

func (o OrderBy) TransformEnd(f Transformer[lexer.Token]) Node

func (OrderBy) TransformStart 

func (o OrderBy) TransformStart(f Transformer[lexer.Token]) Node

func (OrderBy) Visit 

func (o OrderBy) Visit(f Transformer[Node]) Node

type OrderCriterium 

type OrderCriterium struct {
	Expression Node
	// { ASC | DESC | USING operator } [ NULLS { FIRST | LAST } ]
	Tail []lexer.Token
}

func (OrderCriterium) Tokens 

func (o OrderCriterium) Tokens() []lexer.Token

func (OrderCriterium) TransformEnd 

func (o OrderCriterium) TransformEnd(f Transformer[lexer.Token]) Node

func (OrderCriterium) TransformStart 

func (o OrderCriterium) TransformStart(f Transformer[lexer.Token]) Node

func (OrderCriterium) Visit 

func (o OrderCriterium) Visit(f Transformer[Node]) Node

type Postfix 

type Postfix struct {
	Expression Node
	Token      lexer.Token
}

Postfix is a node with a single operator and a left operand. e.g. mytable.column(+)

Also used as an item of comma separated list. The comma is stored in the Token field.

func (Postfix) Is 

func (p Postfix) Is(s string) bool

Is reports whether the operator is one string.

func (Postfix) RemoveOperator 

func (p Postfix) RemoveOperator() Postfix

RemoveOperator removes the operator of the postfix node.

Move spacings before operator.

func (Postfix) SetOperator 

func (p Postfix) SetOperator(t lexer.Token) Postfix

SetOperator sets the operator of the postfix node.

Move spacings after operator.

func (Postfix) Tokens 

func (p Postfix) Tokens() []lexer.Token

func (Postfix) TransformEnd 

func (p Postfix) TransformEnd(f Transformer[lexer.Token]) Node

func (Postfix) TransformStart 

func (p Postfix) TransformStart(f Transformer[lexer.Token]) Node

func (Postfix) Visit 

func (p Postfix) Visit(f Transformer[Node]) Node

type Prefix 

type Prefix struct {
	Token      lexer.Token
	Expression Node
}

Prefix is a node with an operator with a single operand after. e.g. NOT 1, -2

Prefix is used to hold item of AND list in ast.Where.

func (Prefix) Is 

func (i Prefix) Is(s string) bool

Is reports whether operator of the Infix node matches a list of strings.

func (Prefix) IsZero 

func (p Prefix) IsZero() bool

func (Prefix) RemoveOperator 

func (p Prefix) RemoveOperator() Prefix

RemoveOperator removes the operator of the prefix node.

Move operator prefix to expression.

func (Prefix) SetOperator 

func (p Prefix) SetOperator(t lexer.Token) Prefix

SetOperator sets the operator of the prefix node.

Move spacings before operator.

func (Prefix) Tokens 

func (p Prefix) Tokens() []lexer.Token

func (Prefix) TransformEnd 

func (p Prefix) TransformEnd(f Transformer[lexer.Token]) Node

func (Prefix) TransformStart 

func (p Prefix) TransformStart(f Transformer[lexer.Token]) Node

func (Prefix) Visit 

func (p Prefix) Visit(f Transformer[Node]) Node
type Search struct {
	Search  []lexer.Token
	Columns Columns
	Set     lexer.Token
	Target  lexer.Token
}

Search holds the SEARCH clause of CTE.

func (Search) Tokens 

func (s Search) Tokens() []lexer.Token

func (Search) TransformEnd 

func (s Search) TransformEnd(f Transformer[lexer.Token]) Node

func (Search) TransformStart 

func (s Search) TransformStart(f Transformer[lexer.Token]) Node

func (Search) Visit 

func (s Search) Visit(f Transformer[Node]) Node

type Select 

type Select struct {
	With     With
	Select   []lexer.Token
	Distinct Clause
	// List is a Grouping only for more than one column.
	// This way, SELECT * or SELECT <scalar> have simpler tree.
	// It's easier to not have to check for Grouping in rules.
	List      Node
	From      From
	Where     Where
	Hierarchy Node // May be an [ast.ConnectBy] or [ast.StartWith]
	GroupBy   Node // May be an [ast.Having] for Oracle HAVING before GROUP BY.
	OrderBy   Node
	Limit     Node // May be [ast.Limit], [ast.Offset] or [ast.Fetch]
}

Select holds a SELECT query.

func (Select) ColumnNames 

func (s Select) ColumnNames() (names []string)

ColumnNames lists the names of the columns in the SELECT clause.

func (Select) IsStar 

func (s Select) IsStar() bool

IsStar reports whether SELECT returns *.

It's use to determine whether the FROM order is important.

func (Select) Tokens 

func (s Select) Tokens() []lexer.Token

func (Select) TransformEnd 

func (s Select) TransformEnd(f Transformer[lexer.Token]) Node

func (Select) TransformStart 

func (s Select) TransformStart(f Transformer[lexer.Token]) Node

func (Select) Visit 

func (s Select) Visit(f Transformer[Node]) Node

type StartWith 

type StartWith struct {
	StartWith []lexer.Token
	Condition Node
	ConnectBy Node
}

func (StartWith) Tokens 

func (s StartWith) Tokens() []lexer.Token

func (StartWith) TransformEnd 

func (s StartWith) TransformEnd(f Transformer[lexer.Token]) Node

func (StartWith) TransformStart 

func (s StartWith) TransformStart(f Transformer[lexer.Token]) Node

func (StartWith) Visit 

func (s StartWith) Visit(f Transformer[Node]) Node

type Statement 

type Statement struct {
	Expression Node
	End        lexer.Token // The final semi-colon.
}

Statement is a single expression followed by a semi-colon.

func (Statement) Tokens 

func (s Statement) Tokens() []lexer.Token

func (Statement) TransformEnd 

func (s Statement) TransformEnd(f Transformer[lexer.Token]) Node

func (Statement) TransformStart 

func (s Statement) TransformStart(f Transformer[lexer.Token]) Node

func (Statement) Visit 

func (s Statement) Visit(f Transformer[Node]) Node

type Statements 

type Statements struct {
	Statements []Node
	EOF        lexer.Token // Holds trailing spaces and comments.
}

Statements is a list of statements until EOF.

func (Statements) Tokens 

func (s Statements) Tokens() []lexer.Token

func (Statements) TransformEnd 

func (s Statements) TransformEnd(f Transformer[lexer.Token]) Node

func (Statements) TransformStart 

func (s Statements) TransformStart(f Transformer[lexer.Token]) Node

TransformStart applies a transformation to the first token of the node.

func (Statements) Visit 

func (s Statements) Visit(f Transformer[Node]) Node

type Transformer 

type Transformer[T any] func(T) T

Transformer is a function that transforms a value into another.

type When 

type When struct {
	When Prefix
	Then Prefix
}

When is the WHEN-THEN clause of a CASE statement.

func (When) Tokens 

func (w When) Tokens() []lexer.Token

func (When) TransformEnd 

func (w When) TransformEnd(f Transformer[lexer.Token]) Node

func (When) TransformStart 

func (w When) TransformStart(f Transformer[lexer.Token]) Node

func (When) Visit 

func (w When) Visit(f Transformer[Node]) Node

type Where 

type Where struct {
	Keyword    lexer.Token // WHERE or ON for JOIN clause.
	Conditions []Prefix
}

Where is a SQL WHERE clause.

func (*Where) And 

func (w *Where) And(condition Node)

And appends a condition to WHERE clause.

func (*Where) Append 

func (w *Where) Append(items ...Prefix)

Append adds an existing WHERE item.

Handles whether AND operator must be added or removed. Preserves spacings.

func (*Where) Delete 

func (w *Where) Delete(index int) (condition Node)

Delete removes a condition from WHERE clause.

Ensure AND consistency.

func (Where) IsZero 

func (w Where) IsZero() bool

func (Where) Tokens 

func (w Where) Tokens() []lexer.Token

func (Where) TransformEnd 

func (w Where) TransformEnd(f Transformer[lexer.Token]) Node

func (Where) TransformStart 

func (w Where) TransformStart(f Transformer[lexer.Token]) Node

func (Where) Visit 

func (w Where) Visit(f Transformer[Node]) Node

type With 

type With struct {
	With      lexer.Token
	Recursive lexer.Token
	CTEs      []CTE
}

With holds Common Table Expressions.

func (With) IsZero 

func (w With) IsZero() bool

func (With) Tokens 

func (w With) Tokens() []lexer.Token

func (With) TransformEnd 

func (w With) TransformEnd(f Transformer[lexer.Token]) Node

func (With) TransformStart 

func (w With) TransformStart(f Transformer[lexer.Token]) Node

func (With) Visit 

func (w With) Visit(f Transformer[Node]) Node

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.