Struct ParseContext 

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

Implementations

impl<'a> ParseContext<'a>

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

pub fn expect_boolean_literal(&mut self) -> Result<bool, ParseError>

Parse a boolean literal (true / false).

Unlike a fuzzy identifier comparison, any non-boolean token is reported explicitly so that SET LOCKED = yes fails instead of silently behaving as false.

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

Parse a DCL object name (username / space name).

Accepts identifiers, keywords, numbers, string literals and hyphenated sequences (e.g. user-name-123, NULL, 12345, "'; DROP USER --").

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

pub fn expect_integer_literal(&mut self) -> Result<i64, ParseError>

pub fn expect_float_literal(&mut self) -> Result<f64, ParseError>

pub fn is_identifier_or_in_token(&self) -> bool

pub fn is_identifier_token(&self) -> bool

pub fn check_keyword(&mut self, keyword: &str) -> bool

pub fn check_keyword_sequence(&mut self, keywords: &[&str]) -> bool

Check if the next tokens match the given sequence (non-consuming)

pub fn consume_keyword(&mut self, keyword: &str) -> Result<(), ParseError>

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

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

pub fn consume_float(&mut self) -> Result<f64, ParseError>

pub fn consume_int(&mut self) -> Result<i64, ParseError>

pub fn consume_token(&mut self, token: &str) -> Result<(), ParseError>

pub fn consume_optional_token(&mut self, token: &str) -> bool

pub fn try_consume_string(&mut self) -> Option<String>

pub fn try_consume_quoted_string(&mut self) -> Option<String>

impl<'a> ParseContext<'a>

pub fn new(input: &'a str) -> Self

pub fn from_string(input: String) -> Self

pub fn checkpoint(&self) -> ParseContextCheckpoint

pub fn restore(&mut self, ckpt: ParseContextCheckpoint)

pub fn set_expression_context( &mut self, expr_context: Arc<ExpressionAnalysisContext>, )

pub fn expression_context(&self) -> &Arc<ExpressionAnalysisContext>

pub fn set_type_alias_manager(&mut self, manager: Arc<TypeAliasManager>)

Attach the shared user-defined type-alias catalog.

pub fn resolve_named_type(&self, name: &str) -> Option<DataType>

Resolve a raw type name through builtin types, then user-defined aliases. Returns None when the name denotes neither.

pub fn expression_context_clone(&self) -> Arc<ExpressionAnalysisContext>

pub fn take_recursive_comprehension(&mut self) -> Option<RecursiveComprehension>

pub fn set_recursive_comprehension(&mut self, rc: RecursiveComprehension)

pub fn lexer(&self) -> &Lexer<'a>

pub fn lexer_mut(&mut self) -> &mut Lexer<'a>

pub fn set_compat_mode(&mut self, enabled: bool)

pub fn set_upsert_mode(&mut self, enabled: bool)

pub fn is_upsert_mode(&self) -> bool

pub fn is_edge_syntax_mode(&self) -> bool

Whether the parser is inside a DML edge statement (src -> dst) where -> is an edge arrow rather than the JSON access operator.

pub fn with_edge_syntax_mode<T>( &mut self, f: impl FnOnce(&mut Self) -> Result<T, ParseError>, ) -> Result<T, ParseError>

Run f with DML edge syntax enabled, then restore the previous mode even on error.

pub fn is_pipe_or_suppressed(&self) -> bool

Whether | should be treated as a list-comprehension separator instead of the bitwise-OR operator in the current parsing position.

pub fn with_pipe_or_suppression<T>( &mut self, value: bool, f: impl FnOnce(&mut Self) -> Result<T, ParseError>, ) -> Result<T, ParseError>

Run f with suppress_pipe_or forced to value, restoring the previous setting afterwards (even on error).

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

pub fn exit_recursion(&mut self)

pub fn add_error(&mut self, error: ParseError)

pub fn add_lex_error(&mut self, error: LexError)

pub fn errors(&self) -> &ParseErrors

pub fn has_errors(&self) -> bool

pub fn take_errors(&mut self) -> ParseErrors

pub fn current_position(&self) -> Position

pub fn current_span(&self) -> Span

pub fn merge_span(&self, start: Position, end: Position) -> Span

pub fn span_since(&self, start: Position) -> Span

Span from start (usually another span’s .start) up to the current cursor position. Replaces the end_span = ctx.current_span() / merge_span(start, end_span.end) idiom spread across the parsers.

pub fn current_token(&self) -> &Token

pub fn next_token(&mut self)

pub fn peek_token(&mut self) -> &Token

Return the next token WITHOUT consuming it.

The lookahead is buffered in the context, so the token returned here is the one that the next ParseContext::next_token (or match_token / expect_token) call will consume.

pub fn match_token(&mut self, expected: TokenKind) -> bool

pub fn check_token(&self, expected: TokenKind) -> bool

pub fn expect_token(&mut self, expected: TokenKind) -> Result<(), ParseError>

pub fn is_recovery_exhausted(&self) -> bool

pub fn record_recovery(&mut self)

pub fn reset_recovery_count(&mut self)

pub fn synchronize(&mut self, scope: RecoveryScope)

pub fn try_recover( &mut self, error: ParseError, scope: RecoveryScope, ) -> Result<(), ParseError>

pub fn recover_clause<T>( &mut self, fallback: impl FnOnce(&mut ParseContext<'_>) -> Result<T, ParseError>, parse: impl FnOnce(&mut ParseContext<'_>) -> Result<T, ParseError>, ) -> Result<T, ParseError>

Parse a clause body with clause-level error recovery.

On failure the error is recorded and the parser synchronizes to the next clause boundary keyword, so the remaining clauses of the enclosing statement are still parsed. fallback must produce a structurally valid placeholder for the failed clause; the query is still rejected once the collected errors are inspected by the caller. Returns the original error, unrecorded, when the recovery limit is reached.

pub fn consume_value(&mut self) -> Result<Value, ParseError>