ast

type BinaryExpr ¶ added in v0.2.0

type BinaryExpr struct {
	Left     Expr
	Operator string
	Right    Expr
	Start    Pos
	EndPos   Pos
}

BinaryExpr represents a binary expression with two operands and an operator. It is used for arithmetic, comparison, and logical operations.

Example Cypher:

n.age > 25 (comparison)
a + b (arithmetic)
x AND y (logical)

Fields:

• Left: The left operand
• Operator: The binary operator (e.g., +, -, *, /, =, <>, <, >, AND, OR)
• Right: The right operand
• Start: Position in source where this expression begins
• EndPos: Position in source where this expression ends

func (e *BinaryExpr) End() Pos

func (e *BinaryExpr) Position() Pos

func (e *BinaryExpr) String() string

type BoolLit ¶ added in v0.2.0

type BoolLit struct {
	Value  bool
	Start  Pos
	EndPos Pos
}

BoolLit represents a boolean literal expression. It holds a true or false value.

Example Cypher:

true
false

Fields:

• Value: The boolean value
• Start: Position in source where this literal begins
• EndPos: Position in source where this literal ends

func (e *BoolLit) End() Pos

func (e *BoolLit) Position() Pos

func (e *BoolLit) String() string

type CaseExpr ¶ added in v0.2.0

type CaseExpr struct {
	Operand Expr
	Whens   []*WhenClause
	Else    Expr
	Start   Pos
	EndPos  Pos
}

CaseExpr represents a CASE expression for conditional logic. It supports both simple and searched CASE forms.

Example Cypher:

CASE n.age
    WHEN 18 THEN 'young'
    WHEN 65 THEN 'senior'
    ELSE 'adult'
END

CASE
    WHEN n.age < 18 THEN 'minor'
    WHEN n.age >= 65 THEN 'senior'
    ELSE 'adult'
END

Fields:

• Operand: Optional expression for simple CASE (nil for searched CASE)
• Whens: List of WHEN clauses
• Else: Optional ELSE expression
• Start: Position in source where this expression begins
• EndPos: Position in source where this expression ends

func (e *CaseExpr) End() Pos

func (e *CaseExpr) Position() Pos

func (e *CaseExpr) String() string

type Clause ¶

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

Clause is the interface for all clause nodes. Clauses are components of statements (e.g., WHERE, RETURN).

In addition to Node methods, Clause implementations must have a clauseNode() method to distinguish them from other node types.

type CreateClause ¶

type CreateClause struct {
	Pattern *PatternExpr
	Start   Pos
	EndPos  Pos
}

CreateClause represents a CREATE clause in a Cypher query. It creates new nodes and relationships in the graph.

Example Cypher:

CREATE (n:Person {name: 'Alice'})
CREATE (a)-[:KNOWS]->(b)

Fields:

• Pattern: The pattern describing what to create
• Start: Position in source where this clause begins
• EndPos: Position in source where this clause ends

func (c *CreateClause) End() Pos

func (c *CreateClause) Position() Pos

func (c *CreateClause) String() string

type CreateStmt ¶ added in v0.2.0

type CreateStmt struct {
	Pattern *PatternExpr
	Clauses []Clause
	Start   Pos
	EndPos  Pos
}

CreateStmt represents a CREATE statement in a Cypher query. It creates new nodes and relationships in the graph.

Example Cypher:

CREATE (n:Person {name: 'Alice', age: 30})
CREATE (a)-[:KNOWS {since: 2020}]->(b)

Fields:

• Pattern: The pattern describing what to create
• Clauses: Additional clauses (e.g., RETURN)
• Start: Position in source where this statement begins
• EndPos: Position in source where this statement ends

func (s *CreateStmt) End() Pos

func (s *CreateStmt) Position() Pos

func (s *CreateStmt) String() string

type DeleteClause ¶

type DeleteClause struct {
	Detach bool
	Items  []Expr
	Start  Pos
	EndPos Pos
}

DeleteClause represents a DELETE clause in a Cypher query. It deletes nodes and relationships. Use Detach to delete nodes without requiring deletion of their relationships first.

Example Cypher:

DELETE r
DETACH DELETE n

Fields:

• Detach: If true, delete nodes and their relationships
• Items: Expressions identifying what to delete
• Start: Position in source where this clause begins
• EndPos: Position in source where this clause ends

func (c *DeleteClause) End() Pos

func (c *DeleteClause) Position() Pos

func (c *DeleteClause) String() string

type DeleteStmt ¶ added in v0.2.0

type DeleteStmt struct {
	Detach bool
	Items  []Expr
	Start  Pos
	EndPos Pos
}

DeleteStmt represents a DELETE statement in a Cypher query. It deletes nodes and relationships.

Example Cypher:

DELETE r
DETACH DELETE n

Fields:

• Detach: If true, delete nodes and their relationships
• Items: Expressions identifying what to delete
• Start: Position in source where this statement begins
• EndPos: Position in source where this statement ends

func (s *DeleteStmt) End() Pos

func (s *DeleteStmt) Position() Pos

func (s *DeleteStmt) String() string

type Direction ¶ added in v0.2.0

type Direction int

Direction represents the direction of a relationship in a pattern. It determines how the relationship connects nodes.

const (
	// DirectionBoth indicates a relationship in either direction (no arrow).
	// Example: (a)--(b)
	DirectionBoth Direction = iota

	// DirectionOutgoing indicates an outgoing relationship (right arrow).
	// Example: (a)-->(b)
	DirectionOutgoing

	// DirectionIncoming indicates an incoming relationship (left arrow).
	// Example: (a)<--(b)
	DirectionIncoming
)

type ExistsExpr ¶ added in v0.2.0

type ExistsExpr struct {
	Pattern *PatternExpr
	Expr    Expr
	Start   Pos
	EndPos  Pos
}

ExistsExpr represents an EXISTS subquery expression. It checks if a pattern exists in the graph.

Example Cypher:

EXISTS { (n)-[:KNOWS]->(m) }
EXISTS { MATCH (n)-[:FRIENDS_WITH]->(m) WHERE m.active = true }

Fields:

• Pattern: The pattern to check for existence
• Expr: Alternative expression form
• Start: Position in source where this expression begins
• EndPos: Position in source where this expression ends

func (e *ExistsExpr) End() Pos

func (e *ExistsExpr) Position() Pos

func (e *ExistsExpr) String() string

type Expr ¶ added in v0.2.0

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

Expr is the interface for all expression nodes. Expressions can be evaluated to produce values.

In addition to Node methods, Expr implementations must have an exprNode() method to distinguish them from other node types.

type FloatLit ¶ added in v0.2.0

type FloatLit struct {
	Value  float64
	Start  Pos
	EndPos Pos
}

FloatLit represents a floating-point literal expression. It holds a 64-bit floating-point value.

Example Cypher:

3.14159
-0.5
1.0e10

Fields:

• Value: The floating-point value
• Start: Position in source where this literal begins
• EndPos: Position in source where this literal ends

func (e *FloatLit) End() Pos

func (e *FloatLit) Position() Pos

func (e *FloatLit) String() string

type FuncCall ¶ added in v0.2.0

type FuncCall struct {
	Name     string
	Args     []Expr
	Distinct bool
	Start    Pos
	EndPos   Pos
}

FuncCall represents a function call expression. It calls a built-in or user-defined function with arguments.

Example Cypher:

count(*)
toUpper(name)
coalesce(a, b, c)

Fields:

• Name: The function name
• Args: The function arguments
• Distinct: If true, applies DISTINCT to the arguments
• Start: Position in source where this expression begins
• EndPos: Position in source where this expression ends

func (e *FuncCall) End() Pos

func (e *FuncCall) Position() Pos

func (e *FuncCall) String() string

type Ident ¶ added in v0.2.0

type Ident struct {
	Name   string
	Start  Pos
	EndPos Pos
}

Ident represents an identifier expression in Cypher. It is used for variable names, property names, and labels.

Example Cypher:

n (variable)
name (property)
Person (label)

Fields:

• Name: The identifier name
• Start: Position in source where this identifier begins
• EndPos: Position in source where this identifier ends

func (e *Ident) End() Pos

func (e *Ident) Position() Pos

func (e *Ident) String() string

type InExpr ¶ added in v0.2.0

type InExpr struct {
	Left   Expr
	Right  Expr
	Start  Pos
	EndPos Pos
}

InExpr represents an IN expression for membership testing. It checks if a value is contained in a list.

Example Cypher:

n.name IN ['Alice', 'Bob', 'Charlie']
x IN range(1, 10)

Fields:

• Left: The value to check for membership
• Right: The list expression
• Start: Position in source where this expression begins
• EndPos: Position in source where this expression ends

func (e *InExpr) End() Pos

func (e *InExpr) Position() Pos

func (e *InExpr) String() string

type IntegerLit ¶ added in v0.2.0

type IntegerLit struct {
	Value  int64
	Start  Pos
	EndPos Pos
}

IntegerLit represents an integer literal expression. It holds a signed 64-bit integer value.

Example Cypher:

42
-100
0

Fields:

• Value: The integer value
• Start: Position in source where this literal begins
• EndPos: Position in source where this literal ends

func (e *IntegerLit) End() Pos

func (e *IntegerLit) Position() Pos

func (e *IntegerLit) String() string

type IsNullExpr ¶ added in v0.2.0

type IsNullExpr struct {
	Expr   Expr
	IsNot  bool
	Negate bool
	Start  Pos
	EndPos Pos
}

IsNullExpr represents an IS NULL or IS NOT NULL expression. It checks if a value is null or not null.

Example Cypher:

n.name IS NULL
n.email IS NOT NULL

Fields:

• Expr: The expression to check
• IsNot: If true, this is IS NOT NULL
• Negate: Alternative negation flag
• Start: Position in source where this expression begins
• EndPos: Position in source where this expression ends

func (e *IsNullExpr) End() Pos

func (e *IsNullExpr) Position() Pos

func (e *IsNullExpr) String() string

type ListComprehension ¶ added in v0.2.0

type ListComprehension struct {
	Var        string
	Variable   string
	InExpr     Expr
	List       Expr
	Where      Expr
	Filter     Expr
	Expr       Expr
	Projection Expr
	Start      Pos
	EndPos     Pos
}

ListComprehension represents a list comprehension expression. It creates a new list by transforming and filtering an existing list.

Example Cypher:

[x IN list WHERE x > 0 | x * 2]
[n IN nodes(p) | n.name]

Fields:

• Var: The iteration variable name
• Variable: Alternative variable name field
• InExpr: The expression being iterated (input list)
• List: Alternative input list field
• Where: Optional filter condition
• Filter: Alternative filter field
• Expr: The projection expression
• Projection: Alternative projection field
• Start: Position in source where this expression begins
• EndPos: Position in source where this expression ends

func (e *ListComprehension) End() Pos

func (e *ListComprehension) Position() Pos

func (e *ListComprehension) String() string

type ListExpr ¶ added in v0.2.0

type ListExpr struct {
	Elements []Expr
	Start    Pos
	EndPos   Pos
}

ListExpr represents a list expression. It is used for list literals and list operations.

Example Cypher:

[1, 2, 3]
['a', 'b', 'c']

Fields:

• Elements: The list elements
• Start: Position in source where this expression begins
• EndPos: Position in source where this expression ends

func (e *ListExpr) End() Pos

func (e *ListExpr) Position() Pos

func (e *ListExpr) String() string

type ListIndexExpr ¶ added in v0.2.0

type ListIndexExpr struct {
	List   Expr
	Index  Expr
	Start  Pos
	EndPos Pos
}

ListIndexExpr represents a list index expression. It accesses an element of a list by index.

Example Cypher:

list[0] (first element)
list[-1] (last element)

Fields:

• List: The list expression
• Index: The index expression
• Start: Position in source where this expression begins
• EndPos: Position in source where this expression ends

func (e *ListIndexExpr) End() Pos

func (e *ListIndexExpr) Position() Pos

func (e *ListIndexExpr) String() string

type ListLit ¶ added in v0.2.0

type ListLit struct {
	Elements []Expr
	Start    Pos
	EndPos   Pos
}

ListLit represents a list literal expression. It holds a list of expressions.

Example Cypher:

[1, 2, 3]
['a', 'b', 'c']
[] (empty list)

Fields:

• Elements: The list elements
• Start: Position in source where this literal begins
• EndPos: Position in source where this literal ends

func (e *ListLit) End() Pos

func (e *ListLit) Position() Pos

func (e *ListLit) String() string

type ListSliceExpr ¶ added in v0.2.0

type ListSliceExpr struct {
	List   Expr
	From   Expr
	To     Expr
	Start  Pos
	EndPos Pos
}

ListSliceExpr represents a list slice expression. It extracts a portion of a list using start and end indices.

Example Cypher:

list[0..3] (first 3 elements)
list[1..] (from index 1 to end)
list[..5] (first 5 elements)

Fields:

• List: The list expression to slice
• From: The start index (nil means from beginning)
• To: The end index (nil means to end)
• Start: Position in source where this expression begins
• EndPos: Position in source where this expression ends

func (e *ListSliceExpr) End() Pos

func (e *ListSliceExpr) Position() Pos

func (e *ListSliceExpr) String() string

type MapExpr ¶ added in v0.2.0

type MapExpr struct {
	Pairs  []*MapPair
	Start  Pos
	EndPos Pos
}

MapExpr represents a map expression. It is used for map literals with key-value pairs.

Example Cypher:

{name: 'Alice', age: 30}
{key: value, another: other}

Fields:

• Pairs: The key-value pairs
• Start: Position in source where this expression begins
• EndPos: Position in source where this expression ends

func (e *MapExpr) End() Pos

func (e *MapExpr) Position() Pos

func (e *MapExpr) String() string

type MapLit ¶ added in v0.2.0

type MapLit struct {
	Properties map[string]Expr
	Start      Pos
	EndPos     Pos
}

MapLit represents a map literal expression. It holds a map of string keys to expression values.

Example Cypher:

{name: 'Alice', age: 30}
{} (empty map)

Fields:

• Properties: The map properties (key-value pairs)
• Start: Position in source where this literal begins
• EndPos: Position in source where this literal ends

func (e *MapLit) End() Pos

func (e *MapLit) Position() Pos

func (e *MapLit) String() string

type MapPair ¶ added in v0.2.0

type MapPair struct {
	Key    string
	Value  Expr
	Start  Pos
	EndPos Pos
}

MapPair represents a key-value pair in a map expression.

Fields:

• Key: The key name
• Value: The value expression
• Start: Position in source where this pair begins
• EndPos: Position in source where this pair ends

func (p *MapPair) End() Pos

func (p *MapPair) Position() Pos

func (p *MapPair) String() string

type MatchClause ¶

type MatchClause struct {
	Optional bool
	Pattern  *PatternExpr
	Where    *WhereExpr
	Return   *ReturnExpr
	Delete   *DeleteClause
	Start    Pos
	EndPos   Pos
}

MatchClause represents a MATCH clause in a Cypher query. It matches patterns in the graph and can optionally be an OPTIONAL MATCH.

Example Cypher:

MATCH (n:Person)-[:KNOWS]->(m:Person)
OPTIONAL MATCH (n)-[:WORKS_AT]->(c:Company)

Fields:

• Optional: If true, this is an OPTIONAL MATCH (returns null for non-matches)
• Pattern: The pattern to match in the graph
• Where: Optional WHERE filter expression
• Return: Optional RETURN clause
• Delete: Optional DELETE clause
• Start: Position in source where this clause begins
• EndPos: Position in source where this clause ends

func (c *MatchClause) End() Pos

func (c *MatchClause) Position() Pos

func (c *MatchClause) String() string

type MatchStmt ¶ added in v0.2.0

type MatchStmt struct {
	Optional bool
	Clauses  []Clause
	Start    Pos
	EndPos   Pos
}

MatchStmt represents a MATCH statement in a Cypher query. It matches patterns in the graph and can include WHERE, SET, RETURN, and DELETE clauses.

Example Cypher:

MATCH (n:Person)-[:KNOWS]->(m:Person)
WHERE n.age > 25
SET m.visited = true
RETURN n, m

Fields:

• Optional: If true, this is an OPTIONAL MATCH
• Clauses: List of clauses in the statement
• Start: Position in source where this statement begins
• EndPos: Position in source where this statement ends

func (s *MatchStmt) End() Pos

func (s *MatchStmt) Position() Pos

func (s *MatchStmt) String() string

type MergeClause ¶ added in v0.2.0

type MergeClause struct {
	Pattern  *PatternExpr
	OnCreate []*SetItem
	OnMatch  []*SetItem
	Start    Pos
	EndPos   Pos
}

MergeClause represents a MERGE clause in a Cypher query. It ensures a pattern exists in the graph, creating it if necessary. Supports ON CREATE and ON MATCH actions.

Example Cypher:

MERGE (n:Person {name: 'Alice'})
ON CREATE SET n.created = timestamp()
ON MATCH SET n.lastSeen = timestamp()

Fields:

• Pattern: The pattern to merge (create if doesn't exist)
• OnCreate: Actions to perform when creating new elements
• OnMatch: Actions to perform when matching existing elements
• Start: Position in source where this clause begins
• EndPos: Position in source where this clause ends

func (c *MergeClause) End() Pos

func (c *MergeClause) Position() Pos

func (c *MergeClause) String() string

type MergeStmt ¶ added in v0.2.0

type MergeStmt struct {
	Pattern  *PatternExpr
	Clause   *MergeClause
	OnCreate []*SetItem
	OnMatch  []*SetItem
	Start    Pos
	EndPos   Pos
}

MergeStmt represents a MERGE statement in a Cypher query. It ensures a pattern exists in the graph, creating it if necessary. Supports ON CREATE and ON MATCH actions.

Example Cypher:

MERGE (n:Person {name: 'Alice'})
ON CREATE SET n.created = timestamp()
ON MATCH SET n.lastSeen = timestamp()

Fields:

• Pattern: The pattern to merge
• Clause: The merge clause with ON CREATE/MATCH actions
• OnCreate: Actions to perform when creating new elements
• OnMatch: Actions to perform when matching existing elements
• Start: Position in source where this statement begins
• EndPos: Position in source where this statement ends

func (s *MergeStmt) End() Pos

func (s *MergeStmt) Position() Pos

func (s *MergeStmt) String() string

type Node ¶ added in v0.2.0

type Node interface {
	Position() Pos
	End() Pos
	String() string
}

Node is the base interface for all AST nodes. Every node in the AST must implement this interface.

Methods:

• Position(): Returns the starting position of the node
• End(): Returns the ending position of the node
• String(): Returns a string representation of the node

type NodePattern ¶

type NodePattern struct {
	Variable     string
	Labels       []string
	Properties   map[string]Expr
	PropertyExpr Expr
	Start        Pos
	EndPos       Pos
}

NodePattern represents a node pattern in a Cypher query. It describes a node with optional variable name, labels, and properties.

Example Cypher:

(n:Person:Employee {name: 'Alice', age: 30})
(:Company)
(n)

Fields:

• Variable: Optional variable name for the node
• Labels: List of labels (e.g., Person, Employee)
• Properties: Map of property names to expressions
• PropertyExpr: Alternative property expression
• Start: Position in source where this node begins
• EndPos: Position in source where this node ends

func (n *NodePattern) End() Pos

func (n *NodePattern) Position() Pos

func (n *NodePattern) String() string

type NullLit ¶ added in v0.2.0

type NullLit struct {
	Start  Pos
	EndPos Pos
}

NullLit represents a NULL literal expression. It represents the absence of a value.

Example Cypher:

NULL

Fields:

• Start: Position in source where this literal begins
• EndPos: Position in source where this literal ends

func (e *NullLit) End() Pos

func (e *NullLit) Position() Pos

func (e *NullLit) String() string

type OrderByExpr ¶ added in v0.2.0

type OrderByExpr struct {
	Items  []*OrderByItem
	Start  Pos
	EndPos Pos
}

OrderByExpr represents an ORDER BY clause in a Cypher query. It specifies how to sort the results.

Example Cypher:

ORDER BY n.age DESC, n.name ASC

Fields:

• Items: List of sort specifications
• Start: Position in source where this clause begins
• EndPos: Position in source where this clause ends

func (c *OrderByExpr) End() Pos

func (c *OrderByExpr) Position() Pos

func (c *OrderByExpr) String() string

type OrderByItem ¶ added in v0.2.0

type OrderByItem struct {
	Expr       Expr
	Descending bool
	Ascending  bool
	Start      Pos
	EndPos     Pos
}

OrderByItem represents a single sort specification in ORDER BY.

Example Cypher:

ORDER BY n.age DESC

Fields:

• Expr: The expression to sort by
• Descending: If true, sort in descending order
• Ascending: If true, sort in ascending order
• Start: Position in source where this item begins
• EndPos: Position in source where this item ends

func (c *OrderByItem) End() Pos

func (c *OrderByItem) Position() Pos

func (c *OrderByItem) String() string

type Param ¶ added in v0.2.0

type Param struct {
	Name   string
	Start  Pos
	EndPos Pos
}

Param represents a parameter placeholder expression. It references a parameter by name without the $ prefix.

Example Cypher:

$name
{age: $minAge}

Fields:

• Name: The parameter name (without $)
• Start: Position in source where this parameter begins
• EndPos: Position in source where this parameter ends

func (e *Param) End() Pos

func (e *Param) Position() Pos

func (e *Param) String() string

type ParamExpr ¶ added in v0.2.0

type ParamExpr struct {
	Name   string
	Start  Pos
	EndPos Pos
}

ParamExpr represents a parameter expression. It is functionally equivalent to Param.

Example Cypher:

$name

Fields:

• Name: The parameter name (without $)
• Start: Position in source where this parameter begins
• EndPos: Position in source where this parameter ends

func (e *ParamExpr) End() Pos

func (e *ParamExpr) Position() Pos

func (e *ParamExpr) String() string

type PathExpr ¶ added in v0.2.0

type PathExpr struct {
	Nodes         []*NodePattern
	Relationships []*RelationPattern
	Start         Pos
	EndPos        Pos
}

PathExpr represents a path expression in a pattern. It describes a sequence of nodes connected by relationships.

Example Cypher:

(n:Person)-[:KNOWS]->(m:Person)<-[:FRIENDS_WITH]-(o:Person)

Fields:

• Nodes: The nodes in the path
• Relationships: The relationships connecting the nodes
• Start: Position in source where this path begins
• EndPos: Position in source where this path ends

func (p *PathExpr) End() Pos

func (p *PathExpr) Position() Pos

func (p *PathExpr) String() string

type Pattern ¶

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

Pattern is the interface for all pattern nodes. Patterns describe graph structures to match or create.

In addition to Node methods, Pattern implementations must have a patternNode() method to distinguish them from other node types.

type PatternComprehension ¶ added in v0.2.0

type PatternComprehension struct {
	Pattern *PatternExpr
	Where   Expr
	Expr    Expr
	Start   Pos
	EndPos  Pos
}

PatternComprehension represents a pattern comprehension expression. It creates a list by matching a pattern and projecting results.

Example Cypher:

[(n)-[:KNOWS]->(m) | m.name]

Fields:

• Pattern: The pattern to match
• Where: Optional filter condition
• Expr: The projection expression
• Start: Position in source where this comprehension begins
• EndPos: Position in source where this comprehension ends

func (p *PatternComprehension) End() Pos

func (p *PatternComprehension) Position() Pos

func (p *PatternComprehension) String() string

type PatternExpr ¶ added in v0.2.0

type PatternExpr struct {
	Parts  []*PatternPart
	Paths  []*PathExpr
	Start  Pos
	EndPos Pos
}

PatternExpr represents a complete pattern expression. It consists of one or more pattern parts that describe the graph structure to match or create.

Example Cypher:

(n:Person)-[:KNOWS]->(m:Person), (m)-[:WORKS_AT]->(c:Company)

Fields:

• Parts: The pattern parts (comma-separated in Cypher)
• Paths: Alternative path representations
• Start: Position in source where this pattern begins
• EndPos: Position in source where this pattern ends

func (p *PatternExpr) End() Pos

func (p *PatternExpr) Position() Pos

func (p *PatternExpr) String() string

type PatternExprItem ¶ added in v0.2.0

type PatternExprItem struct {
	Variable string
	Path     *PathExpr
	Start    Pos
	EndPos   Pos
}

PatternExprItem represents an item within a pattern expression. It is similar to PatternPart but used in different contexts.

Fields:

• Variable: Optional variable name
• Path: The path expression
• Start: Position in source where this item begins
• EndPos: Position in source where this item ends

func (p *PatternExprItem) End() Pos

func (p *PatternExprItem) Position() Pos

func (p *PatternExprItem) String() string

type PatternPart ¶ added in v0.2.0

type PatternPart struct {
	Variable string
	Path     *PathExpr
	Start    Pos
	EndPos   Pos
}

PatternPart represents a single part of a pattern expression. It can be named with a variable and contains a path.

Example Cypher:

p = (n:Person)-[:KNOWS]->(m:Person)

Fields:

• Variable: Optional variable name for the entire pattern part
• Path: The path expression within this part
• Start: Position in source where this part begins
• EndPos: Position in source where this part ends

func (p *PatternPart) End() Pos

func (p *PatternPart) Position() Pos

func (p *PatternPart) String() string

type Pos ¶ added in v0.2.0

type Pos struct {
	Line   int
	Column int
	Offset int
}

Pos represents a position in the source code. It is used for error reporting and source mapping.

Fields:

• Line: The 1-based line number
• Column: The 1-based column number
• Offset: The 0-based byte offset from the start of the file

type PropertyAccessExpr ¶ added in v0.2.0

type PropertyAccessExpr struct {
	Target   Expr
	Property string
	Start    Pos
	EndPos   Pos
}

PropertyAccessExpr represents a property access expression (e.g., n.name). It accesses a property of a node, relationship, or map.

Example Cypher:

n.name
user.email
person.address.city (nested access)

Fields:

• Target: The expression whose property is being accessed
• Property: The property name
• Start: Position in source where this expression begins
• EndPos: Position in source where this expression ends

func (e *PropertyAccessExpr) End() Pos

func (e *PropertyAccessExpr) Position() Pos

func (e *PropertyAccessExpr) String() string

type Query ¶ added in v0.2.0

type Query struct {
	Statements []Stmt
	Start      Pos
	EndPos     Pos
}

Query represents a complete Cypher query. It can contain multiple statements separated by semicolons.

Example Cypher:

MATCH (n) RETURN n;
CREATE (m:Person {name: 'Alice'})

Fields:

• Statements: List of statements in the query
• Start: Position in source where this query begins
• EndPos: Position in source where this query ends

func (q *Query) End() Pos

func (q *Query) Position() Pos

func (q *Query) String() string

type RelationPattern ¶

type RelationPattern struct {
	Variable       string
	Types          []string
	Direction      Direction
	Properties     map[string]Expr
	MinHops        *int
	MaxHops        *int
	VariableLength bool
	RightArrow     bool
	LeftArrow      bool
	Start          Pos
	EndPos         Pos
}

RelationPattern represents a relationship pattern in a Cypher query. It describes a relationship with optional variable name, types, direction, properties, and variable length constraints.

Example Cypher:

-[r:KNOWS {since: 2020}]->
-[:FRIENDS_WITH|COLLEAGUE]->
-[*1..3]-> (variable length)
-->

Fields:

• Variable: Optional variable name for the relationship
• Types: List of relationship types
• Direction: The relationship direction
• Properties: Map of property names to expressions
• MinHops: Minimum number of hops (for variable length)
• MaxHops: Maximum number of hops (for variable length)
• VariableLength: If true, this is a variable-length pattern
• RightArrow: If true, has a right arrow
• LeftArrow: If true, has a left arrow
• Start: Position in source where this relationship begins
• EndPos: Position in source where this relationship ends

func (r *RelationPattern) End() Pos

func (r *RelationPattern) Position() Pos

func (r *RelationPattern) String() string

type RemoveClause ¶

type RemoveClause struct {
	Items  []*RemoveItemExpr
	Start  Pos
	EndPos Pos
}

RemoveClause represents a REMOVE clause in a Cypher query. It removes properties and labels from nodes and relationships.

Example Cypher:

REMOVE n.age
REMOVE n:Person

Fields:

• Items: List of items to remove
• Start: Position in source where this clause begins
• EndPos: Position in source where this clause ends

func (c *RemoveClause) End() Pos

func (c *RemoveClause) Position() Pos

func (c *RemoveClause) String() string

type RemoveItemExpr ¶ added in v0.2.0

type RemoveItemExpr struct {
	Target  Expr
	IsLabel bool
	Label   string
	Start   Pos
	EndPos  Pos
}

RemoveItemExpr represents a single item in a REMOVE statement. It can remove a property or a label.

Example Cypher:

REMOVE n.age      // Property
REMOVE n:Person   // Label

Fields:

• Target: The target expression
• IsLabel: If true, this is a label removal
• Label: The label name (if IsLabel is true)
• Start: Position in source where this item begins
• EndPos: Position in source where this item ends

func (r *RemoveItemExpr) End() Pos

func (r *RemoveItemExpr) Position() Pos

func (r *RemoveItemExpr) String() string

type RemoveStmt ¶ added in v0.2.0

type RemoveStmt struct {
	Items  []*RemoveItemExpr
	Start  Pos
	EndPos Pos
}

RemoveStmt represents a REMOVE statement in a Cypher query. It removes properties and labels from nodes and relationships.

Example Cypher:

REMOVE n.age
REMOVE n:Person

Fields:

• Items: List of items to remove
• Start: Position in source where this statement begins
• EndPos: Position in source where this statement ends

func (s *RemoveStmt) End() Pos

func (s *RemoveStmt) Position() Pos

func (s *RemoveStmt) String() string

type ReturnClause ¶

type ReturnClause struct {
	Items    []*ReturnItemExpr
	Distinct bool
	OrderBy  *OrderByExpr
	Skip     Expr
	Limit    Expr
	Start    Pos
	EndPos   Pos
}

ReturnClause represents a RETURN clause in a Cypher query. It specifies what data to return from the query.

Example Cypher:

RETURN n, m.name AS friendName
RETURN DISTINCT n.age ORDER BY n.age DESC LIMIT 10

Fields:

• Items: List of expressions to return
• Distinct: If true, return only distinct rows
• OrderBy: Optional ORDER BY clause
• Skip: Optional number of rows to skip
• Limit: Optional maximum number of rows to return
• Start: Position in source where this clause begins
• EndPos: Position in source where this clause ends

func (c *ReturnClause) End() Pos

func (c *ReturnClause) Position() Pos

func (c *ReturnClause) String() string

type ReturnExpr ¶ added in v0.2.0

type ReturnExpr struct {
	Items    []*ReturnItemExpr
	Distinct bool
	OrderBy  *OrderByExpr
	Skip     Expr
	Limit    Expr
	Start    Pos
	EndPos   Pos
}

ReturnExpr represents a RETURN expression in a Cypher query. It is functionally equivalent to ReturnClause.

Fields:

• Items: List of expressions to return
• Distinct: If true, return only distinct rows
• OrderBy: Optional ORDER BY clause
• Skip: Optional number of rows to skip
• Limit: Optional maximum number of rows to return
• Start: Position in source where this expression begins
• EndPos: Position in source where this expression ends

func (c *ReturnExpr) End() Pos

func (c *ReturnExpr) Position() Pos

func (c *ReturnExpr) String() string

type ReturnItemExpr ¶ added in v0.2.0

type ReturnItemExpr struct {
	Expr   Expr
	Alias  string
	Start  Pos
	EndPos Pos
}

ReturnItemExpr represents a single item in a RETURN clause. It can have an optional alias (AS clause).

Example Cypher:

RETURN n.name AS personName

Fields:

• Expr: The expression to return
• Alias: Optional alias name (empty if no AS clause)
• Start: Position in source where this item begins
• EndPos: Position in source where this item ends

func (c *ReturnItemExpr) End() Pos

func (c *ReturnItemExpr) Position() Pos

func (c *ReturnItemExpr) String() string

type ReturnStmt ¶ added in v0.2.0

type ReturnStmt struct {
	Distinct bool
	Items    []*ReturnItemExpr
	OrderBy  *OrderByExpr
	Skip     Expr
	Limit    Expr
	Return   *ReturnExpr
	Start    Pos
	EndPos   Pos
}

ReturnStmt represents a RETURN statement in a Cypher query. It specifies what data to return.

Example Cypher:

RETURN n, m.name AS friendName
RETURN DISTINCT n.age ORDER BY n.age DESC LIMIT 10

Fields:

• Distinct: If true, return only distinct rows
• Items: List of expressions to return
• OrderBy: Optional ORDER BY clause
• Skip: Optional number of rows to skip
• Limit: Optional maximum number of rows
• Return: The return expression
• Start: Position in source where this statement begins
• EndPos: Position in source where this statement ends

func (s *ReturnStmt) End() Pos

func (s *ReturnStmt) Position() Pos

func (s *ReturnStmt) String() string

type SetClause ¶

type SetClause struct {
	Items  []*SetItem
	Start  Pos
	EndPos Pos
}

SetClause represents a SET clause in a Cypher query. It sets properties on nodes and relationships.

Example Cypher:

SET n.name = 'Alice'
SET n += {age: 30, city: 'NYC'}
SET n:Person:Employee

Fields:

• Items: List of SET operations to perform
• Start: Position in source where this clause begins
• EndPos: Position in source where this clause ends

func (c *SetClause) End() Pos

func (c *SetClause) Position() Pos

func (c *SetClause) String() string

type SetItem ¶ added in v0.2.0

type SetItem struct {
	Target   Expr
	Value    Expr
	Operator string
	IsLabel  bool
	Start    Pos
	EndPos   Pos
}

SetItem represents a single SET operation. It can set a property, add labels, or perform a map update.

Example Cypher:

SET n.name = 'Alice'           // Property assignment
SET n += {age: 30}             // Map update
SET n:Person:Employee          // Label addition

Fields:

• Target: The target expression (property or node)
• Value: The value to set
• Operator: The operator (= or +=)
• IsLabel: If true, this is a label operation
• Start: Position in source where this item begins
• EndPos: Position in source where this item ends

func (s *SetItem) End() Pos

func (s *SetItem) Position() Pos

func (s *SetItem) String() string

type SetStmt ¶ added in v0.2.0

type SetStmt struct {
	Items  []*SetItem
	Start  Pos
	EndPos Pos
}

SetStmt represents a SET statement in a Cypher query. It sets properties on nodes and relationships.

Example Cypher:

SET n.name = 'Alice'
SET n += {age: 30, city: 'NYC'}
SET n:Person:Employee

Fields:

• Items: List of SET operations
• Start: Position in source where this statement begins
• EndPos: Position in source where this statement ends

func (s *SetStmt) End() Pos

func (s *SetStmt) Position() Pos

func (s *SetStmt) String() string

type Stmt ¶ added in v0.2.0

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

Stmt is the interface for all statement nodes. Statements represent executable actions in Cypher queries.

In addition to Node methods, Stmt implementations must have a stmtNode() method to distinguish them from other node types.

type StringLit ¶ added in v0.2.0

type StringLit struct {
	Value  string
	Start  Pos
	EndPos Pos
}

StringLit represents a string literal expression. It holds a string value (quotes are not included).

Example Cypher:

'hello'
"world"
'it\'s a test'

Fields:

• Value: The string value (without quotes)
• Start: Position in source where this literal begins
• EndPos: Position in source where this literal ends

func (e *StringLit) End() Pos

func (e *StringLit) Position() Pos

func (e *StringLit) String() string

type UnaryExpr ¶ added in v0.2.0

type UnaryExpr struct {
	Operator string
	Operand  Expr
	Start    Pos
	EndPos   Pos
}

UnaryExpr represents a unary expression with an operator and operand. It is used for negation and other unary operations.

Example Cypher:

-n (negation)
NOT x (logical not)

Fields:

• Operator: The unary operator (e.g., -, NOT)
• Operand: The operand expression
• Start: Position in source where this expression begins
• EndPos: Position in source where this expression ends

func (e *UnaryExpr) End() Pos

func (e *UnaryExpr) Position() Pos

func (e *UnaryExpr) String() string

type UnionClause ¶ added in v0.2.0

type UnionClause struct {
	All    bool
	Start  Pos
	EndPos Pos
}

UnionClause represents a UNION clause in a Cypher query. It combines results from multiple queries.

Example Cypher:

MATCH (n) RETURN n.name
UNION
MATCH (m) RETURN m.name

MATCH (n) RETURN n.name
UNION ALL
MATCH (m) RETURN m.name

Fields:

• All: If true, this is UNION ALL (keeps duplicates)
• Start: Position in source where this clause begins
• EndPos: Position in source where this clause ends

func (c *UnionClause) End() Pos

func (c *UnionClause) Position() Pos

func (c *UnionClause) String() string

type UnwindClause ¶ added in v0.2.0

type UnwindClause struct {
	Expr   Expr
	Var    string
	Start  Pos
	EndPos Pos
}

UnwindClause represents an UNWIND clause in a Cypher query. It expands a list into a sequence of rows.

Example Cypher:

UNWIND [1, 2, 3] AS num
UNWIND $names AS name

Fields:

• Expr: The list expression to unwind
• Var: The variable name for each element
• Start: Position in source where this clause begins
• EndPos: Position in source where this clause ends

func (c *UnwindClause) End() Pos

func (c *UnwindClause) Position() Pos

func (c *UnwindClause) String() string

type UnwindStmt ¶ added in v0.2.0

type UnwindStmt struct {
	List     Expr
	Variable string
	Return   *ReturnExpr
	Start    Pos
	EndPos   Pos
}

UnwindStmt represents an UNWIND statement in a Cypher query. It expands a list into a sequence of rows.

Example Cypher:

UNWIND [1, 2, 3] AS num
UNWIND $names AS name

Fields:

• List: The list expression to unwind
• Variable: The variable name for each element
• Return: Optional RETURN clause
• Start: Position in source where this statement begins
• EndPos: Position in source where this statement ends

func (s *UnwindStmt) End() Pos

func (s *UnwindStmt) Position() Pos

func (s *UnwindStmt) String() string

type Visitor ¶ added in v0.2.0

type Visitor interface {
	// Visit is called for each node in the AST.
	// It returns the visitor to use for child nodes, or nil to skip children.
	// An error can be returned to stop the walk.
	Visit(node Node) (w Visitor, err error)
}

Visitor is the interface for visiting AST nodes. Implementations can perform operations on nodes during the walk.

type Walker ¶ added in v0.2.0

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

Walker walks an AST and calls the visitor for each node.

func NewWalker(v Visitor) *Walker

func (w *Walker) Walk(node Node) error

type WhenClause ¶ added in v0.2.0

type WhenClause struct {
	Condition Expr
	Result    Expr
	Start     Pos
	EndPos    Pos
}

WhenClause represents a WHEN clause in a CASE expression. It pairs a condition with a result.

Example Cypher:

WHEN 18 THEN 'young'

Fields:

• Condition: The condition to match (for searched CASE)
• Result: The result expression if the condition matches
• Start: Position in source where this clause begins
• EndPos: Position in source where this clause ends

func (c *WhenClause) End() Pos

func (c *WhenClause) Position() Pos

func (c *WhenClause) String() string

type WhereClause ¶

type WhereClause struct {
	Expr   Expr
	Start  Pos
	EndPos Pos
}

WhereClause represents a WHERE clause in a Cypher query. It filters results based on a boolean expression.

Example Cypher:

WHERE n.age > 25 AND n.name STARTS WITH 'A'

Fields:

• Expr: The boolean expression to evaluate
• Start: Position in source where this clause begins
• EndPos: Position in source where this clause ends

func (c *WhereClause) End() Pos

func (c *WhereClause) Position() Pos

func (c *WhereClause) String() string

type WhereExpr ¶ added in v0.2.0

type WhereExpr struct {
	Expr   Expr
	Start  Pos
	EndPos Pos
}

WhereExpr represents a WHERE expression in a Cypher query. It is similar to WhereClause but used in different contexts.

Fields:

• Expr: The boolean expression to evaluate
• Start: Position in source where this expression begins
• EndPos: Position in source where this expression ends

func (c *WhereExpr) End() Pos

func (c *WhereExpr) Position() Pos

func (c *WhereExpr) String() string

type WithClause ¶ added in v0.2.0

type WithClause struct {
	Items    []*ReturnItemExpr
	Distinct bool
	OrderBy  *OrderByExpr
	Skip     Expr
	Limit    Expr
	Where    Expr
	Start    Pos
	EndPos   Pos
}

WithClause represents a WITH clause in a Cypher query. It chains query parts, passing results to the next part.

Example Cypher:

WITH n, count(*) AS cnt ORDER BY cnt DESC LIMIT 10

Fields:

• Items: List of expressions to pass forward
• Distinct: If true, return only distinct rows
• OrderBy: Optional ORDER BY clause
• Skip: Optional number of rows to skip
• Limit: Optional maximum number of rows to return
• Where: Optional WHERE filter
• Start: Position in source where this clause begins
• EndPos: Position in source where this clause ends

func (c *WithClause) End() Pos

func (c *WithClause) Position() Pos

func (c *WithClause) String() string

type WithStmt ¶ added in v0.2.0

type WithStmt struct {
	Items    []*ReturnItemExpr
	Distinct bool
	OrderBy  *OrderByExpr
	Skip     Expr
	Limit    Expr
	Where    Expr
	Start    Pos
	EndPos   Pos
}

WithStmt represents a WITH statement in a Cypher query. It chains query parts, passing results to the next part.

Example Cypher:

WITH n, count(*) AS cnt
ORDER BY cnt DESC
LIMIT 10

Fields:

• Items: List of expressions to pass forward
• Distinct: If true, return only distinct rows
• OrderBy: Optional ORDER BY clause
• Skip: Optional number of rows to skip
• Limit: Optional maximum number of rows
• Where: Optional WHERE filter
• Start: Position in source where this statement begins
• EndPos: Position in source where this statement ends

func (s *WithStmt) End() Pos

func (s *WithStmt) Position() Pos

func (s *WithStmt) String() string