ast

type BooleanLiteral ¶

type BooleanLiteral struct {
	Token token.Token
	Value bool
}

BooleanLiteral represents true or false.

func (bl *BooleanLiteral) String() string

func (bl *BooleanLiteral) TokenLiteral() string

type CallClause ¶

type CallClause struct {
	Token         token.Token
	ProcedureName *QualifiedName
	Args          []Expression
	Yield         []*YieldItem // nil means no YIELD
	Where         Expression   // CALL … YIELD … WHERE …  (openCypher extension)
}

CallClause represents a CALL procedureName(args) YIELD … clause.

func (c *CallClause) String() string

func (c *CallClause) TokenLiteral() string

type CallSubquery ¶

type CallSubquery struct {
	Token          token.Token   // CALL
	ImportVars     []*Identifier // variables in the scope clause (var1, var2); may be empty
	Body           *SingleQuery
	InTransactions bool
	BatchSize      Expression // may be nil
	Concurrent     bool
}

CallSubquery represents a CALL { … } subquery clause (Neo4j 5+). This is distinct from a CALL procedureName(…) procedure invocation.

Forms:

CALL (var1, var2) { query }                           — explicit scope clause
CALL { query }                                        — implicit (deprecated in 5.x)
CALL (var1) { query } IN TRANSACTIONS [OF n ROWS]     — batched form
CALL (var1) { query } IN n CONCURRENT TRANSACTIONS   — concurrent form

func (c *CallSubquery) String() string

func (c *CallSubquery) TokenLiteral() string

type CaseExpression ¶

type CaseExpression struct {
	Token        token.Token
	Operand      Expression // nil for searched CASE
	Alternatives []*CaseWhen
	Default      Expression // nil when no ELSE clause
}

CaseExpression represents a CASE expression (simple or generic).

func (c *CaseExpression) String() string

func (c *CaseExpression) TokenLiteral() string

type CaseWhen ¶

type CaseWhen struct {
	When Expression
	Then Expression
}

CaseWhen is one WHEN … THEN … branch.

type CollectSubquery ¶

type CollectSubquery struct {
	Token token.Token
	Body  *SingleQuery
}

CollectSubquery represents COLLECT { … } — a subquery expression that returns a list of values from the RETURN clause of the inner query.

MATCH (n) SET n.friends = COLLECT { MATCH (n)-[:KNOWS]->(m) RETURN m.name }

func (c *CollectSubquery) String() string

func (c *CollectSubquery) TokenLiteral() string

type CountStar ¶

type CountStar struct {
	Token token.Token
}

CountStar represents the COUNT(*) aggregate form.

func (cs *CountStar) String() string

func (cs *CountStar) TokenLiteral() string

type CountSubquery ¶

type CountSubquery struct {
	Token token.Token
	Body  *SingleQuery
}

CountSubquery represents COUNT { … } — a subquery expression that returns the number of rows the inner query produces. Distinct from count() aggregate.

MATCH (n) WHERE COUNT { (n)-[:KNOWS]->(m) } > 3 RETURN n

func (c *CountSubquery) String() string

func (c *CountSubquery) TokenLiteral() string

type CreateClause ¶

type CreateClause struct {
	Token   token.Token
	Pattern *Pattern
}

CreateClause represents a CREATE clause.

func (c *CreateClause) String() string

func (c *CreateClause) TokenLiteral() string

type DeleteClause ¶

type DeleteClause struct {
	Token  token.Token
	Detach bool
	Exprs  []Expression
}

DeleteClause represents DELETE or DETACH DELETE.

func (d *DeleteClause) String() string

func (d *DeleteClause) TokenLiteral() string

type DynamicPropertyAccess ¶

type DynamicPropertyAccess struct {
	Token  token.Token
	Object Expression
	Key    Expression
}

DynamicPropertyAccess represents expr[keyExpr].

func (d *DynamicPropertyAccess) String() string

func (d *DynamicPropertyAccess) TokenLiteral() string

type ExistsSubquery ¶

type ExistsSubquery struct {
	Token token.Token
	Query *Query
}

ExistsSubquery represents EXISTS { matchPattern [WHERE pred] }.

func (e *ExistsSubquery) String() string

func (e *ExistsSubquery) TokenLiteral() string

type Expression ¶

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

Expression represents a value-producing construct (literals, operators, property access, function calls, pattern predicates, …).

type FinishClause ¶

type FinishClause struct {
	Token token.Token
}

FinishClause represents the FINISH clause (Cypher 25). Terminates a query without returning any rows.

func (f *FinishClause) String() string

func (f *FinishClause) TokenLiteral() string

type FloatLiteral ¶

type FloatLiteral struct {
	Token token.Token
	Value float64
}

FloatLiteral represents a floating-point literal.

func (fl *FloatLiteral) String() string

func (fl *FloatLiteral) TokenLiteral() string

type ForeachClause ¶

type ForeachClause struct {
	Token   token.Token
	Var     *Identifier
	InExpr  Expression
	Clauses []Statement
}

ForeachClause represents FOREACH (var IN expr | clause…).

func (f *ForeachClause) String() string

func (f *ForeachClause) TokenLiteral() string

type FunctionCall ¶

type FunctionCall struct {
	Token     token.Token
	Name      *QualifiedName
	Distinct  bool
	Arguments []Expression
}

FunctionCall represents a function invocation: name(args…) or name(DISTINCT arg).

func (fc *FunctionCall) String() string

func (fc *FunctionCall) TokenLiteral() string

type Identifier ¶

type Identifier struct {
	Token    token.Token
	Value    string
	Backtick bool // true when the source used backtick escaping
}

Identifier represents a simple name (variable, label, property key, …).

func (i *Identifier) String() string

func (i *Identifier) TokenLiteral() string

type InExpression ¶

type InExpression struct {
	Token token.Token
	Left  Expression
	Right Expression
	Not   bool
}

InExpression represents expr IN listExpr.

func (ie *InExpression) String() string

func (ie *InExpression) TokenLiteral() string

type InfixExpression ¶

type InfixExpression struct {
	Token    token.Token
	Left     Expression
	Operator string
	Right    Expression
}

InfixExpression represents a binary infix operation (a + b, a AND b, …).

func (ie *InfixExpression) String() string

func (ie *InfixExpression) TokenLiteral() string

type IntegerLiteral ¶

type IntegerLiteral struct {
	Token token.Token
	Value int64
}

IntegerLiteral represents an integer literal.

func (il *IntegerLiteral) String() string

func (il *IntegerLiteral) TokenLiteral() string

type IsNullExpression ¶

type IsNullExpression struct {
	Token token.Token
	Expr  Expression
	Not   bool
}

IsNullExpression represents expr IS NULL or expr IS NOT NULL.

func (in *IsNullExpression) String() string

func (in *IsNullExpression) TokenLiteral() string

type LabelExpression ¶

type LabelExpression struct {
	Token  token.Token
	Target Expression
	Labels []*Identifier
}

LabelExpression represents n:Label or n:Label1|Label2 (used in WHERE and SET).

func (l *LabelExpression) String() string

func (l *LabelExpression) TokenLiteral() string

type LabelFilter ¶

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

LabelFilter is the interface implemented by all label boolean expression nodes.

type LabelFilterAnd ¶

type LabelFilterAnd struct {
	Token token.Token
	Left  LabelFilter
	Right LabelFilter
}

func (l *LabelFilterAnd) String() string

func (l *LabelFilterAnd) TokenLiteral() string

type LabelFilterName ¶

type LabelFilterName struct {
	Token token.Token
	Value string
}

func (l *LabelFilterName) String() string

func (l *LabelFilterName) TokenLiteral() string

type LabelFilterNot ¶

type LabelFilterNot struct {
	Token token.Token
	Inner LabelFilter
}

func (l *LabelFilterNot) String() string

func (l *LabelFilterNot) TokenLiteral() string

type LabelFilterOr ¶

type LabelFilterOr struct {
	Token token.Token
	Left  LabelFilter
	Right LabelFilter // nil when there is only one term
}

LabelFilterExpression represents a label boolean expression used in Neo4j 5+ node and relationship patterns: (n:A&B), (n:A|B), (n:!A), (n:%).

The grammar has three forms:

LabelOr  = LabelAnd  ("|" LabelAnd)*
LabelAnd = LabelNot  ("&" LabelNot)*
LabelNot = "!" LabelNot | LabelAtom
LabelAtom = LabelName | "%" | "(" LabelOr ")"

The miniparser in parser/label.go produces this tree directly.

func (l *LabelFilterOr) String() string

func (l *LabelFilterOr) TokenLiteral() string

type LabelFilterWildcard ¶

type LabelFilterWildcard struct {
	Token token.Token
}

func (l *LabelFilterWildcard) String() string

func (l *LabelFilterWildcard) TokenLiteral() string

type ListComprehension ¶

type ListComprehension struct {
	Token    token.Token
	Variable *Identifier
	InExpr   Expression
	Where    Expression // may be nil
	MapExpr  Expression // may be nil (bare [x IN list] returns filtered list)
}

ListComprehension represents [var IN expr WHERE pred | mapExpr].

func (lc *ListComprehension) String() string

func (lc *ListComprehension) TokenLiteral() string

type ListLiteral ¶

type ListLiteral struct {
	Token    token.Token
	Elements []Expression
}

ListLiteral represents a list literal: [expr, expr, …].

func (l *ListLiteral) String() string

func (l *ListLiteral) TokenLiteral() string

type ListSlice ¶

type ListSlice struct {
	Token token.Token
	List  Expression
	From  Expression // may be nil
	To    Expression // may be nil
}

ListSlice represents list[from..to] (either bound may be nil for open ranges).

func (ls *ListSlice) String() string

func (ls *ListSlice) TokenLiteral() string

type LoadCSVClause ¶

type LoadCSVClause struct {
	Token           token.Token
	WithHeaders     bool
	URL             Expression
	Alias           *Identifier
	FieldTerminator Expression // optional FIELDTERMINATOR expr
}

LoadCSVClause represents a LOAD CSV [WITH HEADERS] FROM expr AS var clause.

func (l *LoadCSVClause) String() string

func (l *LoadCSVClause) TokenLiteral() string

type MapLiteral ¶

type MapLiteral struct {
	Token token.Token
	Pairs []*MapPair
}

MapLiteral represents a property map literal: {key: val, …}.

func (m *MapLiteral) String() string

func (m *MapLiteral) TokenLiteral() string

type MapPair ¶

type MapPair struct {
	Key   *Identifier
	Value Expression
}

MapPair is one key–value entry in a MapLiteral.

type MatchClause ¶

type MatchClause struct {
	Token    token.Token // MATCH
	Optional bool
	Pattern  *Pattern
	Where    Expression // may be nil
}

MatchClause represents a MATCH (or OPTIONAL MATCH) clause.

func (m *MatchClause) String() string

func (m *MatchClause) TokenLiteral() string

type MergeClause ¶

type MergeClause struct {
	Token    token.Token
	Pattern  *PatternPart // single path pattern (not a full comma list)
	OnMatch  []*SetItem
	OnCreate []*SetItem
}

MergeClause represents a MERGE clause with optional ON MATCH / ON CREATE actions.

func (m *MergeClause) String() string

func (m *MergeClause) TokenLiteral() string

type Node ¶

type Node interface {
	TokenLiteral() string
	String() string
}

Node is the root interface for every AST element.

type NodePattern ¶

type NodePattern struct {
	Token       token.Token
	Variable    *Identifier   // may be nil
	Labels      []*Identifier // may be empty; used for simple :Label:Label form
	LabelFilter LabelFilter   // may be nil; used for boolean :A&B|!C form (Neo4j 5+)
	Properties  Expression    // MapLiteral or Parameter; may be nil
	InlineWhere Expression    // may be nil; inline WHERE predicate: (n WHERE n.age > 18)
}

NodePattern represents a node in a pattern: (var:Label {props}).

func (n *NodePattern) String() string

func (n *NodePattern) TokenLiteral() string

type NullLiteral ¶

type NullLiteral struct {
	Token token.Token
}

NullLiteral represents the null literal.

func (nl *NullLiteral) String() string

func (nl *NullLiteral) TokenLiteral() string

type Parameter ¶

type Parameter struct {
	Token token.Token
	Name  string
}

Parameter represents a query parameter ($name or {name}).

func (p *Parameter) String() string

func (p *Parameter) TokenLiteral() string

type Pattern ¶

type Pattern struct {
	Parts []*PatternPart
}

Pattern is a comma-separated list of PatternParts in a MATCH or CREATE clause.

func (p *Pattern) String() string

func (p *Pattern) TokenLiteral() string

type PatternComprehension ¶

type PatternComprehension struct {
	Token   token.Token
	Pattern *PatternPart
	Where   Expression // may be nil
	MapExpr Expression
}

PatternComprehension represents [(var)-[r]->(n) WHERE pred | expr].

func (pc *PatternComprehension) String() string

func (pc *PatternComprehension) TokenLiteral() string

type PatternElement ¶

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

PatternElement is either a NodePattern or a RelationshipPattern.

type PatternPart ¶

type PatternPart struct {
	Variable *Identifier // may be nil
	All      bool        // true when produced by allShortestPaths(…)
	Elements []PatternElement
}

PatternPart is one path pattern, optionally bound to a variable. e.g. p = (a)-[:KNOWS]->(b)

func (p *PatternPart) String() string

func (p *PatternPart) TokenLiteral() string

type PrefixExpression ¶

type PrefixExpression struct {
	Token    token.Token
	Operator string
	Right    Expression
}

PrefixExpression represents a unary prefix operation (NOT x, -x, …).

func (pe *PrefixExpression) String() string

func (pe *PrefixExpression) TokenLiteral() string

type ProjectionItem ¶

type ProjectionItem struct {
	Expr  Expression
	Alias *Identifier // may be nil
	Star  bool        // true for bare RETURN *
}

ProjectionItem is one item in RETURN or WITH. Alias is nil when no AS clause is present.

func (p *ProjectionItem) String() string

func (p *ProjectionItem) TokenLiteral() string

type PropertyAccess ¶

type PropertyAccess struct {
	Token    token.Token
	Object   Expression
	Property *Identifier
}

PropertyAccess represents node.property or relationship.property.

func (pa *PropertyAccess) String() string

func (pa *PropertyAccess) TokenLiteral() string

type QualifiedName ¶

type QualifiedName struct {
	Parts []*Identifier
}

QualifiedName represents a dotted procedure/function name, e.g. apoc.util.sleep.

func (q *QualifiedName) String() string

func (q *QualifiedName) TokenLiteral() string

type QuantifierExpression ¶

type QuantifierExpression struct {
	Token      token.Token
	Quantifier string // "ALL", "ANY", "NONE", "SINGLE", "FILTER"
	Variable   *Identifier
	InExpr     Expression
	Where      Expression
}

QuantifierExpression represents ALL/ANY/NONE/SINGLE/FILTER(var IN expr WHERE pred).

func (q *QuantifierExpression) String() string

func (q *QuantifierExpression) TokenLiteral() string

type Query ¶

type Query struct {
	Parts []*SingleQuery // len >= 1
	Union []*UnionPart   // len == len(Parts)-1; empty when no UNION
}

Query is the root AST node produced by parsing a single Cypher input. It is either a RegularQuery (one or more SingleQuerys joined by UNION) or a StandaloneCall (a bare CALL … YIELD … RETURN).

func (q *Query) String() string

func (q *Query) TokenLiteral() string

type ReduceExpression ¶

type ReduceExpression struct {
	Token       token.Token
	Accumulator *Identifier
	Seed        Expression
	Variable    *Identifier
	InExpr      Expression
	MapExpr     Expression
}

ReduceExpression represents reduce(acc = seed, x IN list | expr). The accumulator variable and seed value are initialised once; the map expression is evaluated for each element and accumulated.

func (r *ReduceExpression) String() string

func (r *ReduceExpression) TokenLiteral() string

type RelationshipPattern ¶

type RelationshipPattern struct {
	Token       token.Token
	Left        bool            // arrow on left side
	Right       bool            // arrow on right side
	Variable    *Identifier     // may be nil
	RelTypes    []*Identifier   // may be empty; alternatives separated by | (simple form)
	LabelFilter LabelFilter     // may be nil; boolean type expression (Neo4j 5+)
	RangeMin    *IntegerLiteral // may be nil (unbounded)
	RangeMax    *IntegerLiteral // may be nil (unbounded)
	HasRange    bool            // true when [*] or [*n..m] is present
	QuantMin    *IntegerLiteral // may be nil; quantified path {n,m} min (Neo4j 25+)
	QuantMax    *IntegerLiteral // may be nil; quantified path {n,m} max
	HasQuant    bool            // true when {n,m} quantifier is present
	Properties  Expression      // MapLiteral or Parameter; may be nil
}

RelationshipPattern represents a relationship in a pattern. Direction:

Left  true,  Right false → <-[…]-
Left  false, Right true  → -[…]->
Left  false, Right false → -[…]-  (undirected)

func (r *RelationshipPattern) String() string

func (r *RelationshipPattern) TokenLiteral() string

type RemoveClause ¶

type RemoveClause struct {
	Token token.Token
	Items []*RemoveItem
}

RemoveClause represents a REMOVE clause (remove properties or labels).

func (r *RemoveClause) String() string

func (r *RemoveClause) TokenLiteral() string

type RemoveItem ¶

type RemoveItem struct {
	Target Expression // PropertyAccess or LabelExpression
}

RemoveItem is one target within REMOVE.

func (ri *RemoveItem) String() string

type ReturnClause ¶

type ReturnClause struct {
	Token    token.Token
	Distinct bool
	Items    []*ProjectionItem
	OrderBy  []*SortItem
	Skip     Expression
	Limit    Expression
}

ReturnClause represents a RETURN clause.

func (r *ReturnClause) String() string

func (r *ReturnClause) TokenLiteral() string

type SetClause ¶

type SetClause struct {
	Token token.Token
	Items []*SetItem
}

SetClause represents a SET clause.

func (s *SetClause) String() string

func (s *SetClause) TokenLiteral() string

type SetItem ¶

type SetItem struct {
	Target   Expression // PropertyAccess, NodeRef, or LabelExpression
	Operator string     // "=", "+=", or ":"
	Value    Expression // nil for label-setting
}

SetItem is one assignment within a SET clause. Cypher SET has several forms:

n.prop = expr        — property assignment
n = {map}            — replace all properties
n += {map}           — merge properties
n:Label              — add label

func (s *SetItem) String() string

type ShortestPathExpression ¶

type ShortestPathExpression struct {
	Token   token.Token
	All     bool // true for allShortestPaths
	Pattern *PatternPart
}

ShortestPathExpression wraps a pattern in shortestPath(…) or allShortestPaths(…).

func (sp *ShortestPathExpression) String() string

func (sp *ShortestPathExpression) TokenLiteral() string

type SingleQuery ¶

type SingleQuery struct {
	Clauses []Statement
}

SingleQuery is a sequential composition of reading, updating, and/or projection clauses that form one arm of a UNION query.

func (s *SingleQuery) String() string

func (s *SingleQuery) TokenLiteral() string

type SortItem ¶

type SortItem struct {
	Expr       Expression
	Descending bool
}

SortItem represents one ORDER BY element.

func (s *SortItem) String() string

type Statement ¶

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

Statement represents a clause-level construct (MATCH, CREATE, RETURN, …).

type StringLiteral ¶

type StringLiteral struct {
	Token token.Token
	Value string // unescaped value
}

StringLiteral represents a string literal ('…' or "…").

func (sl *StringLiteral) String() string

func (sl *StringLiteral) TokenLiteral() string

type StringPredicate ¶

type StringPredicate struct {
	Token     token.Token
	Left      Expression
	Predicate string // "STARTS WITH", "ENDS WITH", "CONTAINS", "=~"
	Right     Expression
	Not       bool
}

StringPredicate represents STARTS WITH, ENDS WITH, CONTAINS, or =~ (regex).

func (sp *StringPredicate) String() string

func (sp *StringPredicate) TokenLiteral() string

type UnionPart ¶

type UnionPart struct {
	Token token.Token // UNION
	All   bool        // true when UNION ALL
}

UnionPart holds the UNION / UNION ALL keyword between two SingleQuery parts.

func (u *UnionPart) String() string

func (u *UnionPart) TokenLiteral() string

type UnwindClause ¶

type UnwindClause struct {
	Token token.Token
	Expr  Expression
	Alias *Identifier
}

UnwindClause represents UNWIND expr AS var.

func (u *UnwindClause) String() string

func (u *UnwindClause) TokenLiteral() string

type WithClause ¶

type WithClause struct {
	Token    token.Token
	Distinct bool
	Items    []*ProjectionItem
	OrderBy  []*SortItem
	Skip     Expression
	Limit    Expression
	Where    Expression
}

WithClause represents a WITH clause (acts as a pipeline projection).

func (w *WithClause) String() string

func (w *WithClause) TokenLiteral() string

type YieldItem ¶

type YieldItem struct {
	Name  *Identifier
	Alias *Identifier // may be nil
}

YieldItem is one item in a YIELD clause.

func (y *YieldItem) String() string