Struct Parser 

pub struct Parser<'a> { /* private fields */ }

Recursive descent parser for the openCypher subset.

Implementations

impl<'a> Parser<'a>

pub fn parse_match_clause( &mut self, optional: bool, ) -> Result<MatchClause, ParseError>

Parse a MATCH clause (TASK-028).

Expects the parser to be positioned at the MATCH keyword. The optional flag indicates whether OPTIONAL was already consumed by the caller.

Grammar: MATCH pattern [WHERE expression]

pub fn parse_return_clause(&mut self) -> Result<ReturnClause, ParseError>

Parse a RETURN clause (TASK-029, TASK-030).

Grammar: RETURN [DISTINCT] items [ORDER BY order_items] [SKIP expr] [LIMIT expr]

pub fn parse_create_clause(&mut self) -> Result<CreateClause, ParseError>

Parse a CREATE clause (TASK-031).

Grammar: CREATE pattern

pub fn parse_set_clause(&mut self) -> Result<SetClause, ParseError>

Parse a SET clause (TASK-032).

Grammar: SET property = expression [, property = expression]*

pub fn parse_remove_clause(&mut self) -> Result<RemoveClause, ParseError>

Parse a REMOVE clause (TASK-032).

Grammar: REMOVE (property_access | variable:Label) [, …]*

pub fn parse_delete_clause( &mut self, detach: bool, ) -> Result<DeleteClause, ParseError>

Parse a DELETE clause (TASK-033).

Grammar: DELETE expression [, expression]* The detach flag indicates whether DETACH was already consumed.

pub fn parse_with_clause(&mut self) -> Result<WithClause, ParseError>

Parse a WITH clause (P2 syntax – parsed but execution returns UnsupportedSyntax).

Grammar: WITH [DISTINCT] items [WHERE expression]

pub fn parse_unwind_clause(&mut self) -> Result<UnwindClause, ParseError>

Parse an UNWIND clause (TASK-068).

Grammar: UNWIND expression AS variable

pub fn parse_merge_clause(&mut self) -> Result<MergeClause, ParseError>

Parse a MERGE clause.

Grammar: MERGE pattern [ON MATCH SET items] [ON CREATE SET items]

pub fn parse_create_index_clause( &mut self, ) -> Result<CreateIndexClause, ParseError>

Parse a CREATE INDEX clause (TASK-098).

Grammar: CREATE INDEX [name] ON :Label(property) The parser has already consumed CREATE and is positioned at INDEX.

pub fn parse_create_edge_index_clause( &mut self, ) -> Result<CreateIndexClause, ParseError>

Parse a CREATE EDGE INDEX clause (CC-T3).

Grammar: CREATE EDGE INDEX [name] ON :RelType(property) The parser has already consumed CREATE and is positioned at EDGE.

pub fn parse_drop_index_clause(&mut self) -> Result<DropIndexClause, ParseError>

Parse a DROP INDEX clause (TASK-098).

Grammar: DROP INDEX name

pub fn parse_create_snapshot_clause( &mut self, ) -> Result<CreateSnapshotClause, ParseError>

Parse a CREATE SNAPSHOT clause (HH-001).

Grammar: CREATE SNAPSHOT (var:Label {props}) [AT TIME expr] FROM MATCH pattern [WHERE filter] RETURN items The parser has already consumed CREATE and is positioned at SNAPSHOT.

pub fn parse_create_hyperedge_clause( &mut self, ) -> Result<CreateHyperedgeClause, ParseError>

Parse a CREATE HYPEREDGE clause (MM-001).

Grammar: CREATE HYPEREDGE (var:Label) FROM (expr [AT TIME expr], …) TO (expr [AT TIME expr], …) The parser has already consumed CREATE and is positioned at HYPEREDGE.

pub fn parse_match_hyperedge_clause( &mut self, ) -> Result<MatchHyperedgeClause, ParseError>

Parse a MATCH HYPEREDGE clause (MM-003).

Grammar: MATCH HYPEREDGE (var:Label) The parser has already consumed MATCH and is positioned at HYPEREDGE.

impl<'a> Parser<'a>

pub fn parse_expression(&mut self) -> Result<Expression, ParseError>

Parse an expression using Pratt parsing (precedence climbing).

pub fn parse_expression_no_and(&mut self) -> Result<Expression, ParseError>

Parse an expression but stop before AND/OR (for BETWEEN TIME expr AND expr). This prevents the AND keyword from being consumed as a binary AND operator.

impl<'a> Parser<'a>

pub fn parse_pattern(&mut self) -> Result<Pattern, ParseError>

Parse a full pattern: node (rel node)* (, node (rel node)*)*

pub fn parse_node_pattern(&mut self) -> Result<NodePattern, ParseError>

Parse a node pattern: (variable:Label:Label2 {prop: value, ...}) All parts are optional except the parentheses.

pub fn parse_map_literal(&mut self) -> Result<MapLiteral, ParseError>

Parse a map literal: {key: value, key: value, ...}

impl<'a> Parser<'a>

pub fn new(tokens: &'a [(Token, Span)], input: &'a str) -> Self

Create a new parser over the given token slice and source text.

pub fn peek(&self) -> Option<&Token>

Peek at the current token without consuming it.

pub fn advance(&mut self) -> Option<&(Token, Span)>

Advance the parser by one token, returning the consumed token and span.

pub fn expect(&mut self, expected: &Token) -> Result<Span, ParseError>

Expect a specific token, consuming it. Returns the span on success.

pub fn check(&self, expected: &Token) -> bool

Check if the current token matches without consuming it.

pub fn eat(&mut self, expected: &Token) -> bool

Consume the current token if it matches, returning true.

pub fn current_span(&self) -> Span

Return the span of the current token, or a zero-length span at EOF.

pub fn offset_to_line_col(&self, offset: usize) -> (usize, usize)

Convert byte offset to (line, column) using the input string.

pub fn error(&self, message: impl Into<String>) -> ParseError

Return a ParseError at the current position with the given message.

pub fn at_end(&self) -> bool

Return true when there are no more tokens.

pub fn expect_ident(&mut self) -> Result<String, ParseError>

Expect and consume an identifier, returning its name.