Struct PostgresGrammar 

pub struct PostgresGrammar;

PostgreSQL grammar — extends ANSI with PostgreSQL-specific syntax.

Trait Implementations

impl Grammar for PostgresGrammar

fn statement_keywords(&self) -> &[&str]

Return the set of keywords that can start a statement in this dialect.

fn dispatch_statement(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

Dispatch a single statement based on the current token. Called from parse_statement after consuming leading trivia.

fn parse_select_clause(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_insert_statement(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_update_statement(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_delete_statement(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_unary_expression(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_table_hint(&self, _ctx: &mut ParseContext<'_>) -> Option<Segment>

Parse an optional table hint after a table reference. Default returns None (ANSI has no table hints). TSQL overrides this to handle WITH(NOLOCK) etc.

fn dispatch_ansi_statement(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

ANSI-only statement dispatch. Dialect impls can call this as fallback.

fn parse_file(&self, ctx: &mut ParseContext<'_>) -> Segment

Parse a complete SQL file: zero or more statements.

fn parse_statement(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

Parse a single statement (terminated by ; or EOF).

fn parse_select_statement(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_select_target(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_from_clause(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_table_reference(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_table_reference_core( &self, ctx: &mut ParseContext<'_>, ) -> Option<Segment>

Core table reference parsing (name/subquery + optional alias), without table hints. Called by parse_table_reference.

fn parse_where_clause(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_group_by_clause(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_having_clause(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_order_by_clause(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_order_expression(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_limit_clause(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_offset_clause(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_with_clause(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_cte_definition(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_set_operation(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_join_clause(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_values_clause(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_set_clause(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_create_statement(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_create_table_body( &self, ctx: &mut ParseContext<'_>, children: Vec<Segment>, ) -> Option<Segment>

fn parse_drop_statement(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_alter_statement(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_expression(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

Parse an expression. This uses a simple precedence climbing approach.

fn parse_or_expression(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_and_expression(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_not_expression(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_comparison_expression( &self, ctx: &mut ParseContext<'_>, ) -> Option<Segment>

fn parse_addition_expression( &self, ctx: &mut ParseContext<'_>, ) -> Option<Segment>

fn parse_multiplication_expression( &self, ctx: &mut ParseContext<'_>, ) -> Option<Segment>

fn parse_primary_expression( &self, ctx: &mut ParseContext<'_>, ) -> Option<Segment>

fn parse_paren_expression(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_paren_subquery(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_case_expression(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_when_clause(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_exists_expression(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_cast_expression(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_data_type(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_identifier(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_qualified_name(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

Parse a possibly qualified name: a, a.b, a.b.c

fn parse_name_or_function(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

fn parse_over_clause(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

Parse OVER clause: OVER (PARTITION BY ... ORDER BY ... ROWS/RANGE ...) or OVER window_name

fn parse_partition_by_clause( &self, ctx: &mut ParseContext<'_>, ) -> Option<Segment>

Parse PARTITION BY expr, expr, …

fn parse_window_order_by(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

Parse ORDER BY inside a window spec (reuses expression parsing).

fn parse_window_frame_clause( &self, ctx: &mut ParseContext<'_>, ) -> Option<Segment>

Parse window frame: ROWS/RANGE/GROUPS frame_spec

fn parse_simple_statement(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

Parse a simple statement (USE, TRUNCATE, etc.) by consuming until end.

fn peek_statement_start(&self, ctx: &ParseContext<'_>) -> bool

Check if current token looks like the start of a new statement.

fn consume_until_statement_end( &self, ctx: &mut ParseContext<'_>, children: &mut Vec<Segment>, )

Consume tokens until semicolon, EOF, or start of new statement. Consume tokens until semicolon, EOF, or start of a new statement. Tracks paren depth so that keywords inside subqueries (e.g. SELECT within (SELECT ...)) do not cause premature termination.

fn parse_paren_block(&self, ctx: &mut ParseContext<'_>) -> Option<Segment>

Parse parenthesized content as a simple block.

fn consume_until_end( &self, ctx: &mut ParseContext<'_>, children: &mut Vec<Segment>, )

Consume tokens until the end of a statement.