Struct Parser 

pub struct Parser { /* private fields */ }

Recursive-descent SQL parser that converts a token stream into an AST.

The parser consumes a Vec<Token> produced by the Tokenizer and builds a tree of Expression nodes. It supports the full SQL grammar including SELECT, DML (INSERT/UPDATE/DELETE/MERGE), DDL (CREATE/ALTER/DROP), window functions, CTEs, set operations, and 30+ dialect-specific extensions.

Quick start

For most use cases the static helper Parser::parse_sql is the simplest entry point:

use polyglot_sql::parser::Parser;

let statements = Parser::parse_sql("SELECT 1; SELECT 2")?;
assert_eq!(statements.len(), 2);

For dialect-aware parsing, use Parser::with_config or Parser::parse_sql_with_config.

Implementations

impl Parser

pub fn new(tokens: Vec<Token>) -> Self

Create a new parser from a pre-tokenized token stream with default configuration.

Prefer Parser::parse_sql if you are starting from a raw SQL string.

pub fn with_config(tokens: Vec<Token>, config: ParserConfig) -> Self

Create a parser from a pre-tokenized token stream with a custom ParserConfig.

pub fn with_source( tokens: Vec<Token>, config: ParserConfig, source: String, ) -> Self

Create a parser with source SQL attached.

The original SQL text is stored so that Command expressions (unparsed dialect-specific statements) can preserve the exact source verbatim.

pub fn parse_sql(sql: &str) -> Result<Vec<Expression>>

Parse one or more SQL statements from a raw string.

This is the main entry point for most callers. It tokenizes the input with the default TokenizerConfig, then parses all semicolon-separated statements and returns them as a Vec<Expression>.

Errors

Returns an error if the input contains invalid tokens or syntax that the parser cannot recognize.

Example

let stmts = Parser::parse_sql("SELECT a FROM t WHERE x = 1")?;

pub fn parse_sql_with_config( sql: &str, tokenizer_config: TokenizerConfig, ) -> Result<Vec<Expression>>

Parse SQL from a string using a custom TokenizerConfig.

Use this variant when the source dialect requires non-default tokenizer settings (e.g. different string quoting or comment syntax).

pub fn parse(&mut self) -> Result<Vec<Expression>>

Parse all remaining statements from the token stream.

Consumes tokens until the end of input, splitting on semicolons. Returns one Expression per statement.

pub fn parse_statement(&mut self) -> Result<Expression>

Parse a single SQL statement from the current position in the token stream.

Dispatches to the appropriate sub-parser based on the leading keyword (SELECT, INSERT, CREATE, etc.). Unknown or dialect-specific statements fall through to a Command expression that preserves the raw SQL text.

pub fn parse_add_column(&mut self) -> Result<Option<Expression>>

parse_add_column - Implemented from Python _parse_add_column Calls: parse_column, parse_column_def_with_exists

pub fn parse_alias(&mut self) -> Result<Option<Expression>>

parse_alias - Parses alias for an expression This method parses just the alias part (AS name or just name) Python: _parse_alias

pub fn parse_alias_with_expr( &mut self, this: Option<Expression>, ) -> Result<Option<Expression>>

parse_alias_with_expr - Wraps an expression with an alias if present

pub fn parse_alter_diststyle(&mut self) -> Result<Option<Expression>>

parse_alter_diststyle - Implemented from Python _parse_alter_diststyle parse_alter_diststyle - Parses ALTER TABLE DISTSTYLE clause (Redshift) Python: parser.py:7797-7802

pub fn parse_alter_session(&mut self) -> Result<Option<Expression>>

parse_alter_session - Parses ALTER SESSION SET/UNSET statements Python: parser.py:7879-7889

pub fn parse_alter_sortkey(&mut self) -> Result<Option<Expression>>

parse_alter_sortkey - Parses ALTER TABLE SORTKEY clause (Redshift) Python: parser.py:7804-7816

pub fn parse_alter_sortkey_impl( &mut self, compound: Option<bool>, ) -> Result<Option<Expression>>

Implementation of parse_alter_sortkey with compound option

pub fn parse_alter_table_add(&mut self) -> Result<Option<Expression>>

parse_alter_table_add - Parses ALTER TABLE ADD clause Python: parser.py:7715-7751

pub fn parse_alter_table_alter(&mut self) -> Result<Option<Expression>>

parse_alter_table_alter - Parses ALTER TABLE ALTER COLUMN clause Python: parser.py:7753-7795

pub fn parse_alter_table_drop(&mut self) -> Result<Option<Expression>>

Parse ALTER TABLE DROP action Note: Main ALTER TABLE DROP logic is implemented inline in parse_alter_table This method provides a separate entry point for the same functionality

pub fn parse_alter_table_rename(&mut self) -> Result<Option<Expression>>

parse_alter_table_rename - Parses ALTER TABLE RENAME clause Python: parser.py:7828-7841

pub fn parse_alter_table_set(&mut self) -> Result<Option<Expression>>

parse_alter_table_set - Parses ALTER TABLE SET clause Python: parser.py:7843-7877

pub fn parse_analyze(&mut self) -> Result<Option<Expression>>

parse_analyze - Implemented from Python _parse_analyze Calls: parse_table_parts, parse_number, parse_table parse_analyze - Parses ANALYZE statement Python: parser.py:7937-7999

pub fn parse_analyze_columns(&mut self) -> Result<Option<Expression>>

parse_analyze_columns - Parses ANALYZE … COLUMNS Python: parser.py:8055-8059 Note: AnalyzeColumns not in expressions.rs, using Identifier instead

pub fn parse_analyze_delete(&mut self) -> Result<Option<Expression>>

parse_analyze_delete - Parses ANALYZE DELETE STATISTICS Python: parser.py:8061-8065

pub fn parse_analyze_histogram(&mut self) -> Result<Option<Expression>>

parse_analyze_histogram - Parses ANALYZE … HISTOGRAM ON Python: parser.py:8073-8108

pub fn parse_analyze_list(&mut self) -> Result<Option<Expression>>

parse_analyze_list - Parses ANALYZE LIST CHAINED ROWS Python: parser.py:8067-8070

pub fn parse_analyze_statistics(&mut self) -> Result<Option<Expression>>

parse_analyze_statistics - Parses ANALYZE … STATISTICS Python: parser.py:8002-8031

pub fn parse_analyze_validate(&mut self) -> Result<Option<Expression>>

parse_analyze_validate - Parses ANALYZE VALIDATE Python: parser.py:8034-8053

pub fn parse_attach_detach(&mut self, is_attach: bool) -> Result<Expression>

parse_attach_detach - Parses ATTACH/DETACH statements (DuckDB) Python: DuckDB._parse_attach_detach

pub fn parse_install(&mut self, force: bool) -> Result<Expression>

parse_install - Parses INSTALL statement (DuckDB) Python: DuckDB._parse_install

pub fn parse_force_statement(&mut self) -> Result<Expression>

parse_force_statement - Parses FORCE INSTALL/CHECKPOINT (DuckDB) Python: DuckDB._parse_force

pub fn parse_summarize_statement(&mut self) -> Result<Expression>

parse_summarize_statement - Parses SUMMARIZE statement (DuckDB) Python: DuckDB parser for SUMMARIZE

pub fn parse_deallocate_prepare(&mut self) -> Result<Expression>

parse_deallocate_prepare - Parses DEALLOCATE PREPARE Presto/Trino syntax for deallocating prepared statements

pub fn parse_as_command(&mut self) -> Result<Option<Expression>>

parse_as_command - Creates Command expression parse_as_command - Parses remaining tokens as a raw command Python: _parse_as_command Used as fallback when specific parsing fails

pub fn parse_assignment(&mut self) -> Result<Option<Expression>>

parse_assignment - Parses assignment expressions (variable := value) Python: _parse_assignment

pub fn parse_auto_increment(&mut self) -> Result<Option<Expression>>

parse_auto_increment - Implemented from Python _parse_auto_increment Calls: parse_bitwise

pub fn parse_auto_property(&mut self) -> Result<Option<Expression>>

parse_auto_property - Implemented from Python _parse_auto_property

pub fn parse_between(&mut self) -> Result<Option<Expression>>

parse_between - Implemented from Python _parse_between

pub fn parse_bitwise(&mut self) -> Result<Option<Expression>>

parse_bitwise - Parses bitwise OR/XOR/AND expressions Python: _parse_bitwise Delegates to the existing parse_bitwise_or in the operator precedence chain

pub fn parse_blockcompression(&mut self) -> Result<Option<Expression>>

parse_blockcompression - Implemented from Python _parse_blockcompression

pub fn parse_boolean(&mut self) -> Result<Option<Expression>>

parse_boolean - Parse boolean literal (TRUE/FALSE) Python: if self._match(TokenType.TRUE): return exp.Boolean(this=True)

pub fn parse_bracket(&mut self) -> Result<Option<Expression>>

parse_bracket - Ported from Python _parse_bracket Parses bracket expressions: array[index], array literal [1,2,3], or struct {key: value}

pub fn parse_bracket_key_value(&mut self) -> Result<Option<Expression>>

parse_bracket_key_value - Ported from Python _parse_bracket_key_value Parses key-value pairs in brackets: key: value or key => value

pub fn parse_ceil_floor(&mut self) -> Result<Option<Expression>>

parse_ceil_floor - Implemented from Python _parse_ceil_floor Calls: parse_lambda, parse_var

pub fn parse_changes(&mut self) -> Result<Option<Expression>>

parse_changes - Implemented from Python _parse_changes Parses: CHANGES(INFORMATION => var) AT|BEFORE(…) END(…)

pub fn parse_char(&mut self) -> Result<Option<Expression>>

parse_char - Parses CHAR/CHR function with optional USING charset Python: CHAR(args…) [USING charset] MySQL: CHAR(n1, n2, … USING charset)

pub fn parse_character_set(&mut self) -> Result<Option<Expression>>

parse_character_set - Ported from Python _parse_character_set parse_character_set - Parses CHARACTER SET property Example: CHARACTER SET = utf8 or CHARACTER SET utf8mb4

pub fn parse_checksum(&mut self) -> Result<Option<Expression>>

parse_checksum - Implemented from Python _parse_checksum

pub fn parse_cluster(&mut self) -> Result<Option<Expression>>

parse_cluster - CLUSTER BY clause for Hive/Spark-style queries Parses a list of ordered expressions (columns with optional ASC/DESC)

pub fn parse_clustered_by(&mut self) -> Result<Option<Expression>>

parse_clustered_by - Implemented from Python _parse_clustered_by

pub fn parse_colon_as_variant_extract( &mut self, this: Expression, ) -> Result<Option<Expression>>

Parse Snowflake colon JSON path extraction: data:field or data:field.subfield Python: def _parse_colon_as_variant_extract(self, this)

pub fn parse_column(&mut self) -> Result<Option<Expression>>

parse_column - Parse column expression Python: this = self._parse_column_reference(); return self._parse_column_ops(this)

pub fn parse_column_constraint(&mut self) -> Result<Option<Expression>>

parse_column_constraint - Ported from Python _parse_column_constraint Parses column-level constraints like NOT NULL, PRIMARY KEY, UNIQUE, DEFAULT, CHECK, etc.

pub fn parse_column_def_with_exists(&mut self) -> Result<Option<Expression>>

parse_column_def_with_exists - Ported from Python _parse_column_def_with_exists Parses a column definition with optional IF [NOT] EXISTS clause

pub fn parse_column_ops(&mut self) -> Result<Option<Expression>>

parse_column_ops - Parses column operations (stub for compatibility)

pub fn parse_column_ops_with_expr( &mut self, this: Option<Expression>, ) -> Result<Option<Expression>>

parse_column_ops_with_expr - Parses column operations (dot access, brackets, casts) Python: _parse_column_ops(this)

pub fn parse_column_reference(&mut self) -> Result<Option<Expression>>

parse_column_reference - Parse column reference (field -> Column) Python: this = self._parse_field(); if isinstance(this, exp.Identifier): return exp.Column(this=this)

pub fn parse_command(&mut self) -> Result<Option<Expression>>

parse_command - Parses a generic SQL command Python: _parse_command Used for commands that we don’t have specific parsing for

pub fn parse_commit_or_rollback(&mut self) -> Result<Option<Expression>>

parse_commit_or_rollback - Implemented from Python _parse_commit_or_rollback

pub fn parse_composite_key_property(&mut self) -> Result<Option<Expression>>

parse_composite_key_property - Implemented from Python _parse_composite_key_property

pub fn parse_comprehension( &mut self, this: Option<Expression>, ) -> Result<Option<Expression>>

parse_comprehension - Implemented from Python _parse_comprehension Parses list comprehension: expr FOR var [, position] IN iterator [IF condition]

pub fn parse_compress(&mut self) -> Result<Option<Expression>>

parse_compress - Parses COMPRESS column constraint (Teradata) Python: _parse_compress Format: COMPRESS or COMPRESS (value1, value2, …)

pub fn parse_conjunction(&mut self) -> Result<Option<Expression>>

parse_conjunction - Parses AND expressions Python: _parse_conjunction Delegates to the existing parse_and in the operator precedence chain

pub fn parse_connect_with_prior(&mut self) -> Result<Option<Expression>>

parse_connect_with_prior - Parses expression in CONNECT BY context with PRIOR support Python: _parse_connect_with_prior This method temporarily treats PRIOR as a prefix operator while parsing the expression

pub fn parse_constraint(&mut self) -> Result<Option<Expression>>

parse_constraint - Parses named or unnamed constraint Python: _parse_constraint

pub fn parse_unnamed_constraints(&mut self) -> Result<Vec<Expression>>

parse_unnamed_constraints - Parses multiple unnamed constraints Python: _parse_unnamed_constraints

pub fn parse_unnamed_constraint(&mut self) -> Result<Option<Expression>>

parse_unnamed_constraint - Parses a single unnamed constraint Python: _parse_unnamed_constraint

pub fn parse_contains_property(&mut self) -> Result<Option<Expression>>

parse_contains_property - Implemented from Python _parse_contains_property

pub fn parse_convert(&mut self) -> Result<Option<Expression>>

parse_convert - Ported from Python _parse_convert Parses CONVERT function: CONVERT(expr USING charset) or CONVERT(expr, type)

pub fn parse_copy_parameters(&mut self) -> Result<Option<Expression>>

parse_copy_parameters - Implemented from Python _parse_copy_parameters parse_copy_parameters - Parses COPY statement parameters Returns a tuple of CopyParameter expressions

pub fn parse_copy_property(&mut self) -> Result<Option<Expression>>

parse_copy_property - Implemented from Python _parse_copy_property

pub fn parse_create_like(&mut self) -> Result<Option<Expression>>

parse_create_like - Implemented from Python _parse_create_like Calls: parse_id_var

pub fn parse_credentials(&mut self) -> Result<Option<Expression>>

parse_credentials - Implemented from Python _parse_credentials

pub fn parse_csv(&mut self) -> Result<Option<Expression>>

parse_csv - Parses comma-separated expressions Python: _parse_csv In Python this takes a parse_method callback, but in Rust we use parse_expression_list

pub fn parse_cte(&mut self) -> Result<Option<Expression>>

parse_cte - Implemented from Python _parse_cte Calls: parse_wrapped_id_vars

pub fn parse_cube_or_rollup(&mut self) -> Result<Option<Expression>>

parse_cube_or_rollup - Ported from Python _parse_cube_or_rollup Parses CUBE(…) or ROLLUP(…) expressions in GROUP BY

pub fn parse_data_deletion_property(&mut self) -> Result<Option<Expression>>

parse_data_deletion_property - Implemented from Python _parse_data_deletion_property Calls: parse_column, parse_retention_period

pub fn parse_datablocksize(&mut self) -> Result<Option<Expression>>

parse_datablocksize - Implemented from Python _parse_datablocksize Calls: parse_number

pub fn parse_dcolon(&mut self) -> Result<Option<Expression>>

parse_dcolon - Delegates to parse_types

pub fn parse_ddl_select(&mut self) -> Result<Option<Expression>>

parse_ddl_select - Ported from Python _parse_ddl_select Parses a SELECT statement in DDL context (CREATE TABLE AS SELECT, INSERT INTO … SELECT)

pub fn parse_for_in(&mut self) -> Result<Expression>

parse_for_in - BigQuery procedural FOR…IN…DO loop Python: BigQuery._parse_for_in Format: FOR variable IN (query) DO statement(s) END FOR Example: FOR record IN (SELECT * FROM t) DO SELECT record.col

pub fn parse_declare(&mut self) -> Result<Option<Expression>>

parse_declare - Parses DECLARE statement Python: _parse_declare Format: DECLARE var1 type [DEFAULT expr], var2 type [DEFAULT expr], …

pub fn parse_declareitem(&mut self) -> Result<Option<Expression>>

parse_declareitem - Parse a DECLARE item (variable declaration) TSQL format: @var AS type [= expr] or @var type [= expr] Also handles: DECLARE name CURSOR FOR SELECT … Also handles: DECLARE @var TABLE (col_defs)

pub fn parse_decode(&mut self) -> Result<Option<Expression>>

parse_decode - Ported from Python _parse_decode Parses Oracle-style DECODE or simple DECODE function If 3+ args: Oracle DECODE(expr, search1, result1, …, default) If 2 args: character set decode (expr, charset)

pub fn parse_definer(&mut self) -> Result<Option<Expression>>

parse_definer - MySQL DEFINER property Parses: DEFINER = user@host

pub fn parse_derived_table_values(&mut self) -> Result<Option<Expression>>

parse_derived_table_values - Implemented from Python _parse_derived_table_values

pub fn parse_dict_property( &mut self, property_name: &str, ) -> Result<Option<Expression>>

parse_dict_property - ClickHouse dictionary property Parses: property_name(kind(key1 value1, key2 value2, …)) property_name should be the already matched property keyword (LAYOUT, SOURCE, etc.)

pub fn parse_dict_range( &mut self, property_name: &str, ) -> Result<Option<Expression>>

parse_dict_range - Implemented from Python _parse_dict_range Parses dictionary range specification: (MIN min_val MAX max_val) or (max_val)

pub fn parse_disjunction(&mut self) -> Result<Option<Expression>>

parse_disjunction - Parses OR expressions Python: _parse_disjunction Delegates to the existing parse_or in the operator precedence chain

pub fn parse_distkey(&mut self) -> Result<Option<Expression>>

parse_distkey - Redshift DISTKEY property for distribution key Parses: DISTKEY(column_name)

pub fn parse_distributed_property(&mut self) -> Result<Option<Expression>>

parse_distributed_property - Implemented from Python _parse_distributed_property parse_distributed_property - Parses DISTRIBUTED BY property Python: parser.py:2462-2481

pub fn parse_drop_column(&mut self) -> Result<Option<Expression>>

Parse DROP COLUMN in ALTER TABLE Note: Main ALTER TABLE DROP COLUMN logic is in parse_alter_table -> AlterTableAction::DropColumn

pub fn parse_drop_partition(&mut self) -> Result<Option<Expression>>

Parse DROP PARTITION in ALTER TABLE Note: Main ALTER TABLE DROP PARTITION logic is in parse_alter_table -> AlterTableAction::DropPartition

pub fn parse_drop_partition_with_exists( &mut self, exists: bool, ) -> Result<Option<Expression>>

Parse DROP PARTITION with exists flag

pub fn parse_equality(&mut self) -> Result<Option<Expression>>

parse_equality - Parses comparison/equality expressions (= <> < > <= >=) Python: _parse_equality Delegates to the existing parse_comparison in the operator precedence chain

pub fn parse_escape(&mut self) -> Result<Option<Expression>>

parse_escape - Parses ESCAPE clause for LIKE patterns Python: _parse_escape Returns the escape character/expression if ESCAPE keyword is found

pub fn parse_exists(&mut self) -> Result<Option<Expression>>

parse_exists - Implemented from Python _parse_exists

pub fn parse_exponent(&mut self) -> Result<Option<Expression>>

parse_exponent - Parses exponent/power expressions Python: _parse_exponent In most dialects, EXPONENT is empty, so this delegates to parse_unary

pub fn parse_expressions(&mut self) -> Result<Option<Expression>>

parse_expressions - Parse comma-separated expressions Returns a Tuple containing all expressions, or None if empty

pub fn parse_extract(&mut self) -> Result<Option<Expression>>

parse_extract - Ported from Python _parse_extract Parses EXTRACT(field FROM expression) function

pub fn parse_factor(&mut self) -> Result<Option<Expression>>

parse_factor - Parses multiplication/division expressions (* / % operators) Python: _parse_factor Delegates to the existing parse_multiplication in the operator precedence chain

pub fn parse_fallback(&mut self) -> Result<Option<Expression>>

parse_fallback - Implemented from Python _parse_fallback

pub fn parse_field(&mut self) -> Result<Option<Expression>>

parse_field - Parse a field (column name, literal, or expression) Python: field = self._parse_primary() or self._parse_function() or self._parse_id_var()

pub fn parse_field_def(&mut self) -> Result<Option<Expression>>

parse_field_def - Ported from Python _parse_field_def Parses a field definition (column name + type + optional constraints)

pub fn parse_foreign_key(&mut self) -> Result<Option<Expression>>

parse_foreign_key - Implemented from Python _parse_foreign_key Calls: parse_key_constraint_options, parse_wrapped_id_vars, parse_references

pub fn parse_format_json(&mut self) -> Result<Option<Expression>>

parse_format_json - Implemented from Python _parse_format_json

pub fn parse_format_name(&mut self) -> Result<Option<Expression>>

parse_format_name - Snowflake FILE_FORMAT = format_name property Parses: format_name (string or identifier)

pub fn parse_freespace(&mut self) -> Result<Option<Expression>>

parse_freespace - Teradata FREESPACE property Parses: FREESPACE = number [PERCENT]

pub fn parse_function(&mut self) -> Result<Option<Expression>>

parse_function - Ported from Python _parse_function Parses function calls like func_name(args) or {fn func_name(args)} (ODBC syntax)

pub fn parse_function_args_list(&mut self) -> Result<Vec<Expression>>

parse_function_args - Ported from Python _parse_function_args Parses the arguments inside a function call, handling aliases and key-value pairs

pub fn parse_function_call(&mut self) -> Result<Option<Expression>>

parse_function_call - Ported from Python _parse_function_call Parses a function call expression like func_name(arg1, arg2, …)

pub fn parse_function_parameter(&mut self) -> Result<Option<Expression>>

parse_function_parameter - Ported from Python _parse_function_parameter Parses a function parameter in CREATE FUNCTION (name type [DEFAULT expr])

pub fn parse_gap_fill(&mut self) -> Result<Option<Expression>>

parse_gap_fill - Ported from Python _parse_gap_fill parse_gap_fill - Parses GAP_FILL function for time series Example: GAP_FILL(TABLE t, ts_column, bucket_width, partitioning_columns, value_columns)

pub fn parse_semantic_view(&mut self) -> Result<Expression>

parse_semantic_view - Parse Snowflake SEMANTIC_VIEW function Example: SEMANTIC_VIEW(foo METRICS a.b, a.c DIMENSIONS a.b, a.c WHERE a.b > ‘1995-01-01’)

pub fn parse_grant_principal(&mut self) -> Result<Option<Expression>>

parse_grant_principal - Implemented from Python _parse_grant_principal Calls: parse_id_var

pub fn parse_grant_privilege(&mut self) -> Result<Option<Expression>>

parse_grant_privilege - Parse a single privilege in GRANT/REVOKE Parses: SELECT, INSERT, UPDATE(col1, col2), DELETE, etc.

pub fn parse_grant_revoke_common(&mut self) -> Result<Option<Expression>>

parse_grant_revoke_common - Parses common parts of GRANT/REVOKE statements Python: _parse_grant_revoke_common Returns a Tuple containing (privileges, kind, securable)

pub fn parse_group(&mut self) -> Result<Option<Expression>>

parse_group - Parse GROUP BY clause Python: if not self._match(TokenType.GROUP_BY): return None; expressions = self._parse_csv(self._parse_disjunction)

pub fn parse_group_concat(&mut self) -> Result<Option<Expression>>

parse_group_concat - Ported from Python _parse_group_concat parse_group_concat - Parses MySQL GROUP_CONCAT function Example: GROUP_CONCAT(DISTINCT col ORDER BY col SEPARATOR ‘,’)

pub fn parse_grouping_set(&mut self) -> Result<Option<Expression>>

parse_grouping_set - Delegates to parse_grouping_sets

pub fn parse_grouping_sets(&mut self) -> Result<Option<Expression>>

parse_grouping_sets - Ported from Python _parse_grouping_sets Parses GROUPING SETS ((…), (…)) in GROUP BY

pub fn parse_having(&mut self) -> Result<Option<Expression>>

parse_having - Parse HAVING clause Python: if not self._match(TokenType.HAVING): return None; return exp.Having(this=self._parse_disjunction())

pub fn parse_having_max(&mut self) -> Result<Option<Expression>>

parse_having_max - Implemented from Python _parse_having_max Calls: parse_column

pub fn parse_heredoc(&mut self) -> Result<Option<Expression>>

parse_heredoc - Implemented from Python _parse_heredoc Parses dollar-quoted strings: $$content$$, $tag$content$tag$

pub fn parse_hint_body(&mut self) -> Result<Option<Expression>>

parse_hint_body - Delegates to parse_hint_fallback_to_string

pub fn parse_hint_fallback_to_string(&mut self) -> Result<Option<Expression>>

parse_hint_fallback_to_string - Parses remaining hint tokens as a raw string Python: _parse_hint_fallback_to_string Used when structured hint parsing fails - collects all remaining tokens

pub fn parse_hint_function_call(&mut self) -> Result<Option<Expression>>

parse_hint_function_call - Delegates to parse_function_call

pub fn parse_historical_data(&mut self) -> Result<Option<Expression>>

parse_historical_data - Snowflake AT/BEFORE time travel clauses Parses: AT(TIMESTAMP => expr) or BEFORE(STATEMENT => ‘id’) etc. Reference: https://docs.snowflake.com/en/sql-reference/constructs/at-before

pub fn parse_id_var(&mut self) -> Result<Option<Expression>>

parse_id_var - Ported from Python _parse_id_var Parses an identifier or variable (more permissive than parse_identifier)

pub fn parse_identifier(&mut self) -> Result<Option<Expression>>

parse_identifier - Parse quoted identifier Python: if self._match(TokenType.IDENTIFIER): return self._identifier_expression(quoted=True)

pub fn parse_if(&mut self) -> Result<Option<Expression>>

Parse IF expression IF(condition, true_value, false_value) - function style IF condition THEN true_value ELSE false_value END - statement style

pub fn parse_in(&mut self) -> Result<Option<Expression>>

parse_in - Ported from Python _parse_in Parses IN expression: expr IN (values…) or expr IN (subquery) Can also parse standalone IN list after IN keyword has been matched

pub fn parse_index(&mut self) -> Result<Option<Expression>>

parse_index - Implemented from Python _parse_index Calls: parse_index_params, parse_id_var

pub fn parse_index_params(&mut self) -> Result<Option<Expression>>

parse_index_params - Implemented from Python _parse_index_params Calls: parse_where, parse_wrapped_properties, parse_wrapped_id_vars

pub fn parse_initcap(&mut self) -> Result<Option<Expression>>

parse_initcap - Ported from Python _parse_initcap parse_initcap - Parses INITCAP function Example: INITCAP(str) or INITCAP(str, delimiter)

pub fn parse_inline(&mut self) -> Result<Option<Expression>>

parse_inline - Implemented from Python _parse_inline

pub fn parse_insert_table(&mut self) -> Result<Option<Expression>>

parse_insert_table - Parse table reference for INSERT statement Parses: table_name [schema] [partition] [alias] This method is a simple wrapper around parse_table for INSERT context

pub fn parse_interpolate(&mut self) -> Result<Option<Expression>>

parse_interpolate - Implemented from Python _parse_interpolate Parses INTERPOLATE clause for ClickHouse ORDER BY WITH FILL

pub fn parse_interval(&mut self) -> Result<Option<Expression>>

parse_interval - Creates Interval expression Parses INTERVAL expressions: INTERVAL ‘1 day’, INTERVAL 1 MONTH, etc.

pub fn parse_interval_span(&mut self) -> Result<Option<Expression>>

parse_interval_span - Implemented from Python _parse_interval_span Calls: parse_function

pub fn parse_into(&mut self) -> Result<Option<Expression>>

parse_into - Implemented from Python _parse_into Parses: INTO [TEMPORARY] [UNLOGGED] [TABLE] table_name Returns the table expression for the INTO clause

pub fn parse_introducer(&mut self) -> Result<Option<Expression>>

parse_introducer - Parses MySQL introducer expression (_charset’string’) Python: _parse_introducer Format: _charset ‘literal’

pub fn parse_is(&mut self) -> Result<Option<Expression>>

parse_is - Implemented from Python _parse_is Calls: parse_null, parse_bitwise

pub fn parse_join(&mut self) -> Result<Option<Expression>>

parse_join - Ported from Python _parse_join Parses a single JOIN clause: [method] [side] [kind] JOIN table [ON condition | USING (columns)] Returns the Join wrapped in an Expression, or None if no join is found

pub fn parse_join_hint(&mut self, hint_name: &str) -> Result<Option<Expression>>

parse_join_hint - Spark/Hive join hints (BROADCAST, MERGE, SHUFFLE_HASH, etc.) Parses: HINT_NAME(table1, table2, …) hint_name should be the already matched hint keyword (BROADCAST, MAPJOIN, etc.)

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

parse_join_parts - Ported from Python _parse_join_parts Returns (method, side, kind) where each is an optional string method: ASOF, NATURAL, POSITIONAL side: LEFT, RIGHT, FULL kind: ANTI, CROSS, INNER, OUTER, SEMI

pub fn parse_journal(&mut self) -> Result<Option<Expression>>

parse_journal - Parses JOURNAL property (Teradata) Python: _parse_journal Creates a JournalProperty expression

pub fn parse_journal_impl( &mut self, no: bool, dual: bool, before: bool, local: bool, after: bool, ) -> Result<Option<Expression>>

Implementation of parse_journal with options

pub fn parse_json_column_def(&mut self) -> Result<Option<Expression>>

parse_json_column_def - Implemented from Python _parse_json_column_def Calls: parse_string, parse_json_schema, parse_id_var

pub fn parse_json_key_value(&mut self) -> Result<Option<Expression>>

parse_json_key_value - Implemented from Python _parse_json_key_value parse_json_key_value - Parses a JSON key-value pair Python: _parse_json_key_value Format: [KEY] key [: | VALUE] value

pub fn parse_json_object(&mut self) -> Result<Option<Expression>>

parse_json_object - Parses JSON_OBJECT function Python: _parse_json_object Handles both JSON_OBJECT and JSON_OBJECTAGG

pub fn parse_json_object_impl( &mut self, agg: bool, ) -> Result<Option<Expression>>

Implementation of JSON object parsing with aggregate flag

pub fn parse_json_schema(&mut self) -> Result<Option<Expression>>

parse_json_schema - Implemented from Python _parse_json_schema

pub fn parse_json_table_columns(&mut self) -> Result<Option<Expression>>

Parse JSON_TABLE COLUMNS clause: COLUMNS (column_def, column_def, …) or COLUMNS column_def Column definitions can be:

• name type PATH ‘json_path’
• name FOR ORDINALITY
• NESTED [PATH] ‘json_path’ COLUMNS (…)

pub fn parse_json_table_column_def(&mut self) -> Result<Option<Expression>>

Parse a single JSON_TABLE column definition Formats:

• name [FOR ORDINALITY] [type] [PATH ‘path’]
• NESTED [PATH] ‘path’ COLUMNS (…)

pub fn parse_json_table(&mut self) -> Result<Option<Expression>>

Parse JSON_TABLE function JSON_TABLE(expr, path COLUMNS (…)) [ON ERROR …] [ON EMPTY …]

pub fn parse_json_value(&mut self) -> Result<Option<Expression>>

parse_json_value - Ported from Python _parse_json_value parse_json_value - Parses JSON_VALUE function Example: JSON_VALUE(json, ‘$.path’ RETURNING type)

pub fn parse_key_constraint_options(&mut self) -> Result<Option<Expression>>

parse_key_constraint_options - Implemented from Python _parse_key_constraint_options

pub fn parse_lambda(&mut self) -> Result<Option<Expression>>

parse_lambda - Ported from Python _parse_lambda Parses lambda expressions: x -> x + 1 or (x, y) -> x + y Also supports DuckDB syntax: LAMBDA x : x + 1

pub fn parse_lambda_arg(&mut self) -> Result<Option<Expression>>

parse_lambda_arg - Delegates to parse_id_var

pub fn parse_lateral(&mut self) -> Result<Option<Expression>>

parse_lateral - Parse LATERAL subquery or table function Python: if self._match(TokenType.LATERAL): return exp.Lateral(this=…, view=…, outer=…)

pub fn parse_limit(&mut self) -> Result<Option<Expression>>

parse_limit - Parse LIMIT clause Python: if self._match(TokenType.LIMIT): return exp.Limit(this=self._parse_term())

pub fn parse_limit_by(&mut self) -> Result<Option<Expression>>

parse_limit_by - Implemented from Python _parse_limit_by

pub fn parse_limit_options(&mut self) -> Result<Option<Expression>>

parse_limit_options - Implemented from Python _parse_limit_options

pub fn parse_load(&mut self) -> Result<Option<Expression>>

parse_load - Implemented from Python _parse_load

pub fn parse_locking(&mut self) -> Result<Option<Expression>>

parse_locking - Implemented from Python _parse_locking Calls: parse_table_parts

pub fn parse_log(&mut self) -> Result<Option<Expression>>

parse_log - Parses LOG property (Teradata) Python: _parse_log Creates a LogProperty expression

pub fn parse_log_impl(&mut self, no: bool) -> Result<Option<Expression>>

Implementation of parse_log with no flag

pub fn parse_match_against(&mut self) -> Result<Option<Expression>>

parse_match_against - Parses MATCH(columns) AGAINST(pattern) Python: parser.py:7125-7153

pub fn parse_match_recognize_measure(&mut self) -> Result<Option<Expression>>

parse_match_recognize_measure - Implemented from Python _parse_match_recognize_measure Parses a MEASURES expression in MATCH_RECOGNIZE: [FINAL|RUNNING] expression

pub fn parse_max_min_by(&mut self, is_max: bool) -> Result<Option<Expression>>

parse_max_min_by - MAX_BY / MIN_BY / ARG_MAX / ARG_MIN aggregate functions Parses: MAX_BY(value, key [, n]) or MIN_BY(value, key [, n]) is_max: true for MAX_BY/ARG_MAX, false for MIN_BY/ARG_MIN

pub fn parse_merge(&mut self) -> Result<Option<Expression>>

Parse MERGE statement Python: def _parse_merge(self) -> exp.Merge

pub fn parse_mergeblockratio(&mut self) -> Result<Option<Expression>>

parse_mergeblockratio - Parses MERGEBLOCKRATIO property (Teradata) Python: _parse_mergeblockratio Format: MERGEBLOCKRATIO = number [PERCENT] or NO MERGEBLOCKRATIO or DEFAULT MERGEBLOCKRATIO

pub fn parse_mergeblockratio_impl( &mut self, no: bool, default: bool, ) -> Result<Option<Expression>>

Implementation of parse_mergeblockratio with options

pub fn parse_modifies_property(&mut self) -> Result<Option<Expression>>

parse_modifies_property - Implemented from Python _parse_modifies_property

pub fn parse_multitable_inserts( &mut self, leading_comments: Vec<String>, ) -> Result<Option<Expression>>

parse_multitable_inserts - Parses Oracle’s multi-table INSERT (INSERT ALL/FIRST) Python: _parse_multitable_inserts Syntax: INSERT ALL|FIRST [WHEN cond THEN] INTO table [(cols)] [VALUES(…)] … SELECT …

pub fn parse_name_as_expression(&mut self) -> Result<Option<Expression>>

parse_name_as_expression - Parse identifier that can be aliased Parses: identifier [AS expression]

pub fn parse_named_window(&mut self) -> Result<Option<Expression>>

parse_named_window - Ported from Python _parse_named_window Parses a named window definition: name AS (spec)

pub fn parse_next_value_for(&mut self) -> Result<Option<Expression>>

parse_next_value_for - Parses NEXT VALUE FOR sequence_name Python: parser.py:6752-6761

pub fn parse_no_property(&mut self) -> Result<Option<Expression>>

parse_no_property - Implemented from Python _parse_no_property

pub fn parse_normalize(&mut self) -> Result<Option<Expression>>

parse_normalize - Ported from Python _parse_normalize parse_normalize - Parses NORMALIZE(expr [, form]) Python: NORMALIZE(expr, form) where form is NFC/NFD/NFKC/NFKD

pub fn parse_not_constraint(&mut self) -> Result<Option<Expression>>

parse_not_constraint - Implemented from Python _parse_not_constraint Parses constraints that start with NOT: NOT NULL, NOT CASESPECIFIC

pub fn parse_null(&mut self) -> Result<Option<Expression>>

parse_null - Parse NULL literal Python: if self._match_set((TokenType.NULL, TokenType.UNKNOWN)): return exp.Null

pub fn parse_number(&mut self) -> Result<Option<Expression>>

parse_number - Parse numeric literal Python: TokenType.NUMBER -> exp.Literal(this=token.text, is_string=False) Handles Hive/Spark numeric suffixes encoded as “number::TYPE” by the tokenizer

pub fn parse_odbc_datetime_literal(&mut self) -> Result<Option<Expression>>

parse_odbc_datetime_literal - Ported from Python _parse_odbc_datetime_literal parse_odbc_datetime_literal - Parses ODBC datetime literals Examples: {d’2023-01-01’}, {t’12:00:00’}, {ts’2023-01-01 12:00:00’}

pub fn parse_offset(&mut self) -> Result<Option<Expression>>

parse_offset - Parse OFFSET clause Python: if self._match(TokenType.OFFSET): return exp.Offset(this=self._parse_term())

pub fn parse_on_condition(&mut self) -> Result<Option<Expression>>

parse_on_condition - Ported from Python _parse_on_condition parse_on_condition - Parses ON EMPTY/ERROR/NULL conditions Example: NULL ON EMPTY, ERROR ON ERROR

pub fn parse_on_handling(&mut self) -> Result<Option<Expression>>

parse_on_handling - Implemented from Python _parse_on_handling Calls: parse_bitwise

pub fn parse_on_property(&mut self) -> Result<Option<Expression>>

parse_on_property - Implemented from Python _parse_on_property

pub fn parse_opclass(&mut self) -> Result<Option<Expression>>

parse_opclass - Ported from Python _parse_opclass parse_opclass - Parses PostgreSQL operator class in index expressions Example: column_name text_pattern_ops

pub fn parse_open_json(&mut self) -> Result<Option<Expression>>

parse_open_json - Parses SQL Server OPENJSON function Example: OPENJSON(json, ‘$.path’) WITH (col1 type ‘$.path’ AS JSON, …)

pub fn parse_operator( &mut self, this: Option<Expression>, ) -> Result<Option<Expression>>

parse_operator - Ported from Python _parse_operator parse_operator - Parses PostgreSQL OPERATOR(op) syntax Example: col1 OPERATOR(~>) col2

pub fn parse_order(&mut self) -> Result<Option<Expression>>

parse_order - Parse ORDER BY clause Python: if not self._match(TokenType.ORDER_BY): return this; return exp.Order(expressions=self._parse_csv(self._parse_ordered))

pub fn parse_ordered(&mut self) -> Result<Option<Expression>>

parse_ordered - Implemented from Python _parse_ordered (wrapper for parse_ordered_item)

pub fn parse_overlay(&mut self) -> Result<Option<Expression>>

parse_overlay - Ported from Python _parse_overlay Parses OVERLAY function: OVERLAY(string PLACING replacement FROM position [FOR length])

pub fn parse_parameter(&mut self) -> Result<Option<Expression>>

parse_parameter - Parse named parameter (@name or :name) Python: this = self._parse_identifier() or self._parse_primary_or_var(); return exp.Parameter(this=this)

pub fn parse_paren(&mut self) -> Result<Option<Expression>>

parse_paren - Ported from Python _parse_paren Parses parenthesized expressions: (expr), (select …), or (a, b, c)

pub fn parse_partition(&mut self) -> Result<Option<Expression>>

parse_partition - Parses PARTITION/SUBPARTITION clause Python: _parse_partition

pub fn parse_partition_and_order(&mut self) -> Result<Option<Expression>>

parse_partition_and_order - Delegates to parse_partition_by

pub fn parse_partition_bound_spec_legacy( &mut self, ) -> Result<Option<Expression>>

parse_partition_bound_spec - Implemented from Python _parse_partition_bound_spec Calls: parse_bitwise, parse_number

pub fn parse_partition_by(&mut self) -> Result<Option<Expression>>

parse_partition_by - Ported from Python _parse_partition_by Parses PARTITION BY expression list

pub fn parse_partitioned_by(&mut self) -> Result<Option<Expression>>

parse_partitioned_by - Parses PARTITIONED BY clause Python: _parse_partitioned_by

pub fn parse_partitioned_by_bucket_or_truncate( &mut self, ) -> Result<Option<Expression>>

parse_partitioned_by_bucket_or_truncate - Parses BUCKET or TRUNCATE partition transforms Python: _parse_partitioned_by_bucket_or_truncate Syntax: BUCKET(col, num_buckets) or TRUNCATE(col, width) Handles both Hive (num, col) and Trino (col, num) ordering, normalizes to (col, num)

pub fn parse_partitioned_of(&mut self) -> Result<Option<Expression>>

parse_partitioned_of - Implemented from Python _parse_partitioned_of

pub fn parse_period_for_system_time(&mut self) -> Result<Option<Expression>>

parse_period_for_system_time - Parses PERIOD FOR SYSTEM_TIME constraint Python: _parse_period_for_system_time Syntax: PERIOD FOR SYSTEM_TIME (start_col, end_col)

pub fn parse_pipe_syntax_aggregate(&mut self) -> Result<Option<Expression>>

parse_pipe_syntax_aggregate - Implemented from Python _parse_pipe_syntax_aggregate

pub fn parse_pipe_syntax_aggregate_fields( &mut self, ) -> Result<Option<Expression>>

parse_pipe_syntax_aggregate_fields - Implemented from Python _parse_pipe_syntax_aggregate_fields Calls: parse_disjunction

pub fn parse_pipe_syntax_aggregate_group_order_by( &mut self, ) -> Result<Option<Expression>>

parse_pipe_syntax_aggregate_group_order_by - Parses pipe syntax aggregate fields with grouping and ordering Python: _parse_pipe_syntax_aggregate_group_order_by Parses comma-separated aggregate fields and separates them into aggregates/groups and ORDER BY specs Returns a Tuple with two elements: (aggregates_and_groups, order_by_specs)

pub fn parse_pipe_syntax_extend(&mut self) -> Result<Option<Expression>>

parse_pipe_syntax_extend - Implemented from Python _parse_pipe_syntax_extend

pub fn parse_pipe_syntax_join(&mut self) -> Result<Option<Expression>>

parse_pipe_syntax_join - Parses JOIN in BigQuery pipe syntax Python: _parse_pipe_syntax_join Format: |> JOIN table ON condition

pub fn parse_pipe_syntax_limit(&mut self) -> Result<Option<Expression>>

parse_pipe_syntax_limit - Parses LIMIT/OFFSET in BigQuery pipe syntax Python: _parse_pipe_syntax_limit Format: |> LIMIT n [OFFSET m]

pub fn parse_pipe_syntax_pivot(&mut self) -> Result<Option<Expression>>

parse_pipe_syntax_pivot - Parses PIVOT in BigQuery pipe syntax Python: _parse_pipe_syntax_pivot Format: |> PIVOT (agg_function FOR column IN (values))

pub fn parse_pipe_syntax_query(&mut self) -> Result<Option<Expression>>

parse_pipe_syntax_query - Parses a query with pipe syntax transformations Python: _parse_pipe_syntax_query Handles queries like: FROM table |> WHERE … |> SELECT … |> AGGREGATE …

pub fn parse_pipe_syntax_select(&mut self) -> Result<Option<Expression>>

parse_pipe_syntax_select - Parses SELECT in BigQuery pipe syntax Python: _parse_pipe_syntax_select Format: |> SELECT expressions

pub fn parse_pipe_syntax_set_operator(&mut self) -> Result<Option<Expression>>

parse_pipe_syntax_set_operator - Parses set operation in BigQuery pipe syntax Python: _parse_pipe_syntax_set_operator Format: |> UNION ALL/INTERSECT/EXCEPT (subquery1, subquery2, …)

pub fn parse_pipe_syntax_tablesample(&mut self) -> Result<Option<Expression>>

parse_pipe_syntax_tablesample - Parses TABLESAMPLE in BigQuery pipe syntax Python: _parse_pipe_syntax_tablesample Format: |> TABLESAMPLE SYSTEM (percent PERCENT)

pub fn parse_pivot_aggregation(&mut self) -> Result<Option<Expression>>

parse_pivot_aggregation - Ported from Python _parse_pivot_aggregation Parses an aggregation function in PIVOT clause, optionally with alias

pub fn parse_pivot_in(&mut self) -> Result<Option<Expression>>

parse_pivot_in - Parses the IN clause of a PIVOT Python: _parse_pivot_in Format: column IN (value1 [AS alias1], value2 [AS alias2], …)

pub fn parse_pivots_for_source( &mut self, source: Expression, ) -> Result<Option<Expression>>

parse_pivots - Ported from Python _parse_pivots Parses one or more PIVOT/UNPIVOT clauses attached to a source expression Uses the existing parse_pivot/parse_unpivot methods

pub fn parse_placeholder(&mut self) -> Result<Option<Expression>>

parse_placeholder - Parse placeholder token (? or :name) Python: if self._match_set(self.PLACEHOLDER_PARSERS): return placeholder

pub fn parse_position(&mut self) -> Result<Option<Expression>>

parse_position - Ported from Python _parse_position Parses POSITION function: POSITION(substr IN str) or POSITION(needle, haystack, start)

pub fn parse_prewhere(&mut self) -> Result<Option<Expression>>

parse_prewhere - Ported from Python _parse_prewhere Parses PREWHERE clause (ClickHouse specific)

pub fn parse_primary_key(&mut self) -> Result<Option<Expression>>

parse_primary_key - Parses PRIMARY KEY constraint Python: _parse_primary_key Can return either PrimaryKeyColumnConstraint (column-level) or PrimaryKey (table-level)

pub fn parse_primary_key_impl( &mut self, wrapped_optional: bool, in_props: bool, ) -> Result<Option<Expression>>

Implementation of parse_primary_key with options

pub fn parse_primary_key_part(&mut self) -> Result<Option<Expression>>

parse_primary_key_part - Delegates to parse_field

pub fn parse_primary_or_var(&mut self) -> Result<Option<Expression>>

parse_primary_or_var - Parses a primary expression or variable Python: _parse_primary_or_var Returns: parse_primary() or parse_var(any_token=True)

pub fn parse_procedure_option(&mut self) -> Result<Option<Expression>>

parse_procedure_option - Implemented from Python _parse_procedure_option

pub fn parse_projections(&mut self) -> Result<Option<Expression>>

parse_projections - Delegates to parse_expressions

pub fn parse_properties(&mut self) -> Result<Option<Expression>>

parse_properties - Parses table/column properties Python: _parse_properties Collects a list of properties using parse_property

pub fn parse_properties_impl( &mut self, before: Option<bool>, ) -> Result<Option<Expression>>

Implementation of parse_properties with before option

pub fn parse_property(&mut self) -> Result<Option<Expression>>

parse_property - Implemented from Python _parse_property Calls: parse_bitwise, parse_column, parse_sequence_properties

pub fn parse_property_assignment(&mut self) -> Result<Option<Expression>>

parse_property_assignment - Ported from Python _parse_property_assignment Parses a property assignment: optionally = or AS, then a value

pub fn parse_property_before(&mut self) -> Result<Option<Expression>>

parse_property_before - Implemented from Python _parse_property_before

pub fn parse_qualify(&mut self) -> Result<Option<Expression>>

parse_qualify - Parse QUALIFY clause (Snowflake, BigQuery) Python: if not self._match(TokenType.QUALIFY): return None; return exp.Qualify(this=self._parse_disjunction())

pub fn parse_range(&mut self) -> Result<Option<Expression>>

parse_range - Parses range expressions (BETWEEN, LIKE, IN, IS, etc.) Python: _parse_range

pub fn parse_reads_property(&mut self) -> Result<Option<Expression>>

parse_reads_property - Implemented from Python _parse_reads_property

pub fn parse_recursive_with_search(&mut self) -> Result<Option<Box<Expression>>>

parse_recursive_with_search - Parse SEARCH/CYCLE clause for recursive CTEs (PostgreSQL) Syntax: SEARCH BREADTH|DEPTH FIRST BY column SET column [USING column] or: CYCLE column SET column USING column

pub fn parse_references(&mut self) -> Result<Option<Expression>>

parse_references - Ported from Python _parse_references Parses REFERENCES clause for foreign key constraints

pub fn parse_refresh(&mut self) -> Result<Option<Expression>>

parse_refresh - Implemented from Python _parse_refresh parse_refresh - Parses REFRESH TABLE or REFRESH MATERIALIZED VIEW Python: parser.py:7656-7668

pub fn parse_refresh_trigger_property( &mut self, ) -> Result<RefreshTriggerProperty>

parse_refresh_trigger_property - Doris REFRESH clause for materialized views Syntax: REFRESH method ON kind [EVERY n UNIT] [STARTS ‘datetime’] Examples: REFRESH COMPLETE ON MANUAL REFRESH AUTO ON COMMIT REFRESH AUTO ON SCHEDULE EVERY 5 MINUTE STARTS ‘2025-01-01 00:00:00’

pub fn parse_remote_with_connection(&mut self) -> Result<Option<Expression>>

parse_remote_with_connection - Implemented from Python _parse_remote_with_connection

pub fn parse_respect_or_ignore_nulls(&mut self) -> Result<Option<Expression>>

parse_respect_or_ignore_nulls - Implemented from Python _parse_respect_or_ignore_nulls

pub fn parse_retention_period(&mut self) -> Result<Option<Expression>>

parse_retention_period - Parses HISTORY_RETENTION_PERIOD (TSQL) Python: _parse_retention_period Format: INFINITE | DAY | DAYS | MONTH | MONTHS | YEAR | YEARS

pub fn parse_returning(&mut self) -> Result<Option<Expression>>

parse_returning - Creates Returning expression Parses RETURNING clause (PostgreSQL) for INSERT/UPDATE/DELETE

pub fn parse_output_clause(&mut self) -> Result<OutputClause>

parse_output_clause - Parses OUTPUT clause (TSQL) Used in INSERT/UPDATE/DELETE and MERGE statements Supports expressions with optional AS aliases: OUTPUT col1, col2 AS alias, col3

pub fn parse_returns(&mut self) -> Result<Option<Expression>>

parse_returns - Implemented from Python _parse_returns Calls: parse_types

pub fn parse_row(&mut self) -> Result<Option<Expression>>

parse_row - Parses ROW FORMAT clause Returns RowFormatSerdeProperty or RowFormatDelimitedProperty

pub fn parse_row_format(&mut self) -> Result<Option<Expression>>

parse_row_format - Implemented from Python _parse_row_format Parses SERDE or DELIMITED row format specifications

pub fn parse_schema(&mut self) -> Result<Option<Expression>>

parse_schema - Ported from Python _parse_schema Parses schema definition: (col1 type1, col2 type2, …) Used for CREATE TABLE column definitions

pub fn parse_security(&mut self) -> Result<Option<Expression>>

parse_security - Implemented from Python _parse_security

pub fn parse_select_or_expression(&mut self) -> Result<Option<Expression>>

parse_select_or_expression - Parses either a SELECT statement or an expression Python: _parse_select_or_expression

pub fn parse_select_query(&mut self) -> Result<Option<Expression>>

parse_select_query - Implemented from Python _parse_select_query Calls: parse_string, parse_table, parse_describe

pub fn parse_sequence_properties(&mut self) -> Result<Option<Expression>>

parse_sequence_properties - Implemented from Python _parse_sequence_properties Calls: parse_number, parse_term, parse_column

pub fn parse_serde_properties( &mut self, with_: bool, ) -> Result<Option<Expression>>

parse_serde_properties - Implemented from Python _parse_serde_properties Parses SERDEPROPERTIES clause: [WITH] SERDEPROPERTIES (key=value, …)

pub fn parse_session_parameter(&mut self) -> Result<Option<Expression>>

parse_session_parameter - Ported from Python _parse_session_parameter parse_session_parameter - Parses session parameters (@@var or @@session.var) Example: @@session.sql_mode, @@global.autocommit

pub fn parse_set_item(&mut self) -> Result<Option<Expression>>

parse_set_item - Ported from Python _parse_set_item Parses an item in a SET statement (GLOBAL, LOCAL, SESSION prefixes, or assignment)

pub fn parse_set_item_assignment(&mut self) -> Result<Option<Expression>>

parse_set_item_assignment - Implemented from Python _parse_set_item_assignment Parses SET variable = value assignments

pub fn parse_set_operations(&mut self) -> Result<Option<Expression>>

parse_set_operations - Parses UNION/INTERSECT/EXCEPT operations This version parses from current position (expects to be at set operator) Python: _parse_set_operations

pub fn parse_set_operations_with_expr( &mut self, this: Option<Expression>, ) -> Result<Option<Expression>>

parse_set_operations_with_expr - Parses set operations with a left expression

pub fn parse_set_transaction(&mut self) -> Result<Option<Expression>>

parse_set_transaction - Implemented from Python _parse_set_transaction

pub fn parse_settings_property(&mut self) -> Result<Option<Expression>>

parse_settings_property - Parses SETTINGS property (ClickHouse) Python: _parse_settings_property Format: SETTINGS key=value, key=value, …

pub fn parse_simplified_pivot( &mut self, is_unpivot: bool, ) -> Result<Option<Expression>>

parse_simplified_pivot - Ported from Python _parse_simplified_pivot Handles DuckDB simplified PIVOT/UNPIVOT syntax: PIVOT table ON columns [IN (…)] USING agg_func [AS alias], … [GROUP BY …] UNPIVOT table ON columns [INTO NAME col VALUE col, …]

pub fn parse_slice(&mut self) -> Result<Option<Expression>>

parse_slice - Parses array slice syntax [start:end:step] Python: _parse_slice Takes an optional ‘this’ expression (the start of the slice)

pub fn parse_slice_with_this( &mut self, this: Option<Expression>, ) -> Result<Option<Expression>>

Implementation of parse_slice with ‘this’ parameter

pub fn parse_sort(&mut self) -> Result<Option<Expression>>

parse_sort - Ported from Python _parse_sort Parses SORT BY clause (Hive/Spark)

pub fn parse_cluster_by_clause(&mut self) -> Result<Option<Expression>>

parse_cluster_by_clause - Parses CLUSTER BY clause (Hive/Spark)

pub fn parse_distribute_by_clause(&mut self) -> Result<Option<Expression>>

parse_distribute_by_clause - Parses DISTRIBUTE BY clause (Hive/Spark)

pub fn parse_sortkey(&mut self) -> Result<Option<Expression>>

parse_sortkey - Redshift/PostgreSQL SORTKEY property Parses SORTKEY(column1, column2, …) with optional COMPOUND modifier

pub fn parse_star(&mut self) -> Result<Option<Expression>>

parse_star - Parse STAR (*) token with optional EXCEPT/REPLACE/RENAME Python: if self._match(TokenType.STAR): return self._parse_star_ops()

pub fn parse_star_op( &mut self, keywords: &[&str], ) -> Result<Option<Vec<Expression>>>

parse_star_op - Helper to parse EXCEPT/REPLACE/RENAME with keywords Returns list of expressions if keywords match

pub fn parse_star_ops(&mut self) -> Result<Option<Expression>>

parse_star_ops - Implemented from Python _parse_star_ops Creates a Star expression with EXCEPT/REPLACE/RENAME clauses Also handles * COLUMNS(pattern) syntax for DuckDB column selection

pub fn parse_stored(&mut self) -> Result<Option<Expression>>

parse_stored - Implemented from Python _parse_stored

pub fn parse_stream(&mut self) -> Result<Option<Expression>>

parse_stream - Implemented from Python _parse_stream

pub fn parse_string(&mut self) -> Result<Option<Expression>>

parse_string - Parse string literal Python: if self._match_set(self.STRING_PARSERS): return STRING_PARSERStoken_type

pub fn parse_string_agg(&mut self) -> Result<Option<Expression>>

parse_string_agg - Parses STRING_AGG function arguments Python: parser.py:6849-6899 Handles DISTINCT, separator, ORDER BY, ON OVERFLOW, WITHIN GROUP

pub fn parse_string_as_identifier(&mut self) -> Result<Option<Expression>>

parse_string_as_identifier - Parses a string literal as a quoted identifier Python: _parse_string_as_identifier Used for cases where a string can be used as an identifier (e.g., MySQL)

pub fn parse_struct_types(&mut self) -> Result<Option<Expression>>

parse_struct_types - Delegates to parse_types

pub fn parse_subquery(&mut self) -> Result<Option<Expression>>

parse_subquery - Ported from Python _parse_subquery Parses a parenthesized SELECT as subquery: (SELECT …)

pub fn parse_substring(&mut self) -> Result<Option<Expression>>

parse_substring - Ported from Python _parse_substring Parses SUBSTRING function with two syntax variants:

1. Standard SQL: SUBSTRING(str FROM start [FOR length])
2. Function style: SUBSTRING(str, start, length)

pub fn parse_system_versioning_property(&mut self) -> Result<Option<Expression>>

parse_system_versioning_property - Implemented from Python _parse_system_versioning_property Calls: parse_table_parts, parse_retention_period

pub fn parse_table(&mut self) -> Result<Option<Expression>>

parse_table - Implemented from Python _parse_table Calls: parse_table_hints, parse_unnest, parse_partition

pub fn parse_table_alias(&mut self) -> Result<Option<Expression>>

parse_table_alias - Ported from Python _parse_table_alias Parses table alias: AS alias [(col1, col2, …)]

pub fn parse_table_hints(&mut self) -> Result<Option<Expression>>

parse_table_hints - Ported from Python _parse_table_hints Parses table hints (SQL Server WITH (…) or MySQL USE/IGNORE/FORCE INDEX)

pub fn parse_truncate_table_hints(&mut self) -> Result<Option<Expression>>

Parse TSQL TRUNCATE table hints: WITH (PARTITIONS(1, 2 TO 5, 10 TO 20, 84)) Unlike regular table hints, PARTITIONS arguments can contain TO ranges.

pub fn parse_table_part(&mut self) -> Result<Option<Expression>>

parse_table_part - Parse a single part of a table reference Tries: identifier, string as identifier, placeholder

pub fn parse_table_parts(&mut self) -> Result<Option<Expression>>

parse_table_parts - Parse catalog.schema.table or schema.table or table Returns a Table expression with all parts

pub fn parse_table_sample(&mut self) -> Result<Option<Expression>>

parse_table_sample - Implemented from Python _parse_table_sample Calls: parse_number, parse_factor, parse_placeholder

pub fn parse_term(&mut self) -> Result<Option<Expression>>

parse_term - Parses addition/subtraction expressions (+ - operators) Python: _parse_term Delegates to the existing parse_addition in the operator precedence chain

pub fn parse_to_table(&mut self) -> Result<Option<Expression>>

parse_to_table - ClickHouse TO table property Parses: TO table_name

pub fn parse_tokens(&mut self) -> Result<Option<Expression>>

parse_tokens - Operator precedence parser

pub fn parse_trim(&mut self) -> Result<Option<Expression>>

parse_trim - Ported from Python _parse_trim Parses TRIM function: TRIM([BOTH|LEADING|TRAILING] chars FROM str) or TRIM(str, chars)

pub fn parse_truncate_table(&mut self) -> Result<Option<Expression>>

parse_truncate_table - Implemented from Python _parse_truncate_table Calls: parse_on_property, parse_partition, parse_function

pub fn parse_ttl(&mut self) -> Result<Option<Expression>>

parse_ttl - Implemented from Python _parse_ttl Parses ClickHouse TTL expression with optional DELETE, RECOMPRESS, TO DISK/VOLUME

pub fn parse_type(&mut self) -> Result<Option<Expression>>

parse_type - Parses a data type expression Python: _parse_type

pub fn parse_type_size(&mut self) -> Result<Option<Expression>>

parse_type_size - Ported from Python _parse_type_size Parses type size parameters like 10 in VARCHAR(10) or 10, 2 in DECIMAL(10, 2)

pub fn parse_types(&mut self) -> Result<Option<Expression>>

parse_types - Implemented from Python _parse_types Calls: parse_string

pub fn parse_unique(&mut self) -> Result<Option<Expression>>

parse_unique - Implemented from Python _parse_unique Parses UNIQUE [KEY|INDEX] [NULLS NOT DISTINCT] [(columns)] [USING index_type]

pub fn parse_unique_key(&mut self) -> Result<Option<Expression>>

parse_unique_key - Parse the key/index name for UNIQUE constraint Simply parses an identifier

pub fn parse_unnest(&mut self) -> Result<Option<Expression>>

parse_unnest - Ported from Python _parse_unnest Parses UNNEST(array_expr) [WITH ORDINALITY] [AS alias]

pub fn parse_unpivot_columns(&mut self) -> Result<Option<Expression>>

parse_unpivot_columns - Implemented from Python _parse_unpivot_columns Python: parser.py:4454-4462 Parses INTO NAME column VALUE col1, col2, …

pub fn parse_unquoted_field(&mut self) -> Result<Option<Expression>>

parse_unquoted_field - Parses a field and converts unquoted identifiers to Var Python: _parse_unquoted_field

pub fn parse_user_defined_function(&mut self) -> Result<Option<Expression>>

parse_user_defined_function - Parses user-defined function call Python: _parse_user_defined_function Parses: schema.function_name(param1, param2, …)

pub fn parse_user_defined_function_expression( &mut self, ) -> Result<Option<Expression>>

parse_user_defined_function_expression - Parse user-defined function expression

pub fn parse_user_defined_type( &mut self, identifier: Identifier, ) -> Result<Option<Expression>>

parse_user_defined_type - Parses a user-defined type reference Python: _parse_user_defined_type Format: schema.type_name or just type_name

pub fn parse_using_identifiers(&mut self) -> Result<Option<Expression>>

parse_using_identifiers - Ported from Python _parse_using_identifiers Parses (col1, col2, …) for JOIN USING clause

pub fn parse_value(&mut self) -> Result<Option<Expression>>

parse_value - Parses a value tuple for INSERT VALUES clause Python: _parse_value Syntax: (expr1, expr2, …) or just expr (single value)

pub fn parse_var(&mut self) -> Result<Option<Expression>>

parse_var - Parse variable reference (unquoted identifier) Python: if self._match(TokenType.VAR): return exp.Var(this=self._prev.text)

pub fn parse_var_from_options(&mut self) -> Result<Option<Expression>>

parse_var_from_options - Ported from Python _parse_var_from_options Parses a variable/identifier from a predefined set of options

pub fn parse_var_or_string(&mut self) -> Result<Option<Expression>>

parse_var_or_string - Delegates to parse_string parse_var_or_string - Parses a string literal or a variable Python: parser.py:7506-7507

pub fn parse_vector_expressions(&mut self) -> Result<Option<Expression>>

parse_vector_expressions - Transforms vector type parameters Python: _parse_vector_expressions In Python, this transforms a list of expressions where the first element (identifier) is converted to a DataType. In Rust, since VECTOR type parsing is handled inline in parse_data_type, this method parses vector expressions (element_type, dimension) from the current position and returns them as a Tuple.

pub fn parse_version(&mut self) -> Result<Option<Expression>>

parse_version - Implemented from Python _parse_version Python: parser.py:4266-4295 Parses FOR SYSTEM_TIME AS OF, VERSIONS BETWEEN, etc.

pub fn parse_volatile_property(&mut self) -> Result<Option<Expression>>

parse_volatile_property - Parses VOLATILE property Python: _parse_volatile_property Returns VolatileProperty for table volatility or StabilityProperty for function stability

pub fn parse_when_matched(&mut self) -> Result<Option<Expression>>

parse_when_matched - Implemented from Python _parse_when_matched Calls: parse_disjunction, parse_star, parse_value Parse WHEN [NOT] MATCHED clauses for MERGE statements This is the public entry point that calls parse_when_matched_clauses

pub fn parse_where(&mut self) -> Result<Option<Expression>>

parse_where - Parse WHERE clause Python: if not self._match(TokenType.WHERE): return None; return exp.Where(this=self._parse_disjunction())

pub fn parse_window(&mut self) -> Result<Option<Expression>>

parse_window - Implemented from Python _parse_window Calls: parse_window_spec, parse_partition_and_order

pub fn parse_window_clause(&mut self) -> Result<Option<Expression>>

parse_window_clause - Ported from Python _parse_window_clause Parses WINDOW named_window_definition [, named_window_definition, …]

pub fn parse_window_spec(&mut self) -> Result<Option<Expression>>

parse_window_spec - Implemented from Python _parse_window_spec

pub fn parse_with_operator(&mut self) -> Result<Option<Expression>>

parse_with_operator - Parse column with operator class (PostgreSQL) Parses: ordered_expression [WITH operator]

pub fn parse_with_property(&mut self) -> Result<Option<Expression>>

parse_with_property - Implemented from Python _parse_with_property Calls: parse_withjournaltable, parse_withisolatedloading, parse_wrapped_properties

pub fn parse_withdata(&mut self) -> Result<Option<Expression>>

parse_withdata - Implemented from Python _parse_withdata

pub fn parse_withisolatedloading(&mut self) -> Result<Option<Expression>>

parse_withisolatedloading - Implemented from Python _parse_withisolatedloading

pub fn parse_withjournaltable(&mut self) -> Result<Option<Expression>>

parse_withjournaltable - Teradata WITH JOURNAL TABLE property Parses: WITH JOURNAL TABLE = table_name

pub fn parse_wrapped(&mut self) -> Result<Option<Expression>>

parse_wrapped - Parses an expression wrapped in parentheses Python: _parse_wrapped(parse_method) This version parses a disjunction (expression) inside parentheses

pub fn parse_wrapped_csv(&mut self) -> Result<Option<Expression>>

parse_wrapped_csv - Parses comma-separated expressions wrapped in parentheses Python: _parse_wrapped_csv(parse_method)

pub fn parse_wrapped_id_vars(&mut self) -> Result<Option<Expression>>

parse_wrapped_id_vars - Parses comma-separated identifiers wrapped in parentheses Python: _parse_wrapped_id_vars

pub fn parse_wrapped_options(&mut self) -> Result<Option<Expression>>

parse_wrapped_options - Implemented from Python _parse_wrapped_options Parses space-separated properties wrapped in parentheses (for Snowflake STAGE_FILE_FORMAT, etc.) Format: = (KEY=VALUE KEY2=VALUE2 …)

pub fn parse_options_list(&mut self) -> Result<Vec<Expression>>

parse_options_list - Parses BigQuery-style OPTIONS list: (key=value, key=value, …) Parses key=value assignments where values can be complex expressions

pub fn parse_environment_list(&mut self) -> Result<Vec<Expression>>

parse_environment_list - Parses Databricks ENVIRONMENT list: (dependencies = ‘…’, environment_version = ‘…’) Parses key=value assignments where values can be string literals

pub fn parse_wrapped_properties(&mut self) -> Result<Option<Expression>>

parse_wrapped_properties - Ported from Python _parse_wrapped_properties Parses properties wrapped in parentheses

pub fn parse_wrapped_select( &mut self, table: bool, ) -> Result<Option<Expression>>

parse_wrapped_select - Ported from Python _parse_wrapped_select Parses wrapped select statements including PIVOT/UNPIVOT and FROM-first syntax

pub fn parse_wrapped_select_default(&mut self) -> Result<Option<Expression>>

Helper for parse_wrapped_select with default table=false

pub fn parse_xml_element(&mut self) -> Result<Option<Expression>>

parse_xml_element - Implemented from Python _parse_xml_element Python: parser.py:6917-6931 Parses XMLELEMENT(NAME name [, expr, …]) or XMLELEMENT(EVALNAME expr [, expr, …])

pub fn parse_xml_namespace(&mut self) -> Result<Option<Expression>>

parse_xml_namespace - Ported from Python _parse_xml_namespace Parses XML namespace declarations

pub fn parse_xml_table(&mut self) -> Result<Option<Expression>>

parse_xml_table - Implemented from Python _parse_xml_table Python: parser.py:6933-6961 Parses XMLTABLE(xpath_expr PASSING xml_doc COLUMNS …)