Struct sql_parser::parser::Parser

struct Parser<'a> {
    sql: &'a str,
    tokens: Vec<(Token, usize)>,
    index: usize,
    recursion_guard: RecursionGuard,
}

SQL Parser

Fields

sql: &'a str

tokens: Vec<(Token, usize)>

index: usize

The index of the first unprocessed token in self.tokens

recursion_guard: RecursionGuard

Implementations

impl<'a> Parser<'a>

fn new(sql: &'a str, tokens: Vec<(Token, usize)>) -> Self

Parse the specified tokens

fn error(&self, pos: usize, message: String) -> ParserError

fn parse_statements(&mut self) -> Result<Vec<Statement<Raw>>, ParserError>

fn parse_statement(&mut self) -> Result<Statement<Raw>, ParserError>

Parse a single top-level statement (such as SELECT, INSERT, CREATE, etc.), stopping before the statement separator, if any.

fn parse_expr(&mut self) -> Result<Expr<Raw>, ParserError>

Parse a new expression

fn parse_subexpr(
    &mut self,
    precedence: Precedence
) -> Result<Expr<Raw>, ParserError>

Parse tokens until the precedence changes

fn parse_subexpr_seeded(
    &mut self,
    precedence: Precedence,
    expr: Expr<Raw>
) -> Result<Expr<Raw>, ParserError>

fn parse_prefix(&mut self) -> Result<Expr<Raw>, ParserError>

Parse an expression prefix

fn parse_parenthesized_expr(&mut self) -> Result<Expr<Raw>, ParserError>

Parses an expression that appears in parentheses, like (1 + 1) or (SELECT 1). Assumes that the opening parenthesis has already been parsed. Parses up to the closing parenthesis without consuming it.

fn parse_function(
    &mut self,
    name: UnresolvedObjectName
) -> Result<Expr<Raw>, ParserError>

fn parse_window_frame(&mut self) -> Result<WindowFrame, ParserError>

fn parse_window_frame_bound(&mut self) -> Result<WindowFrameBound, ParserError>

Parse CURRENT ROW or { <positive number> | UNBOUNDED } { PRECEDING | FOLLOWING }

fn parse_case_expr(&mut self) -> Result<Expr<Raw>, ParserError>

fn parse_cast_expr(&mut self) -> Result<Expr<Raw>, ParserError>

Parse a SQL CAST function e.g. CAST(expr AS FLOAT)

fn parse_exists_expr(&mut self) -> Result<Expr<Raw>, ParserError>

Parse a SQL EXISTS expression e.g. WHERE EXISTS(SELECT ...).

fn parse_homogenizing_function(
    &mut self,
    function: HomogenizingFunction
) -> Result<Expr<Raw>, ParserError>

fn parse_nullif_expr(&mut self) -> Result<Expr<Raw>, ParserError>

fn parse_extract_expr(&mut self) -> Result<Expr<Raw>, ParserError>

fn parse_row_expr(&mut self) -> Result<Expr<Raw>, ParserError>

fn parse_trim_expr(&mut self) -> Result<Expr<Raw>, ParserError>

fn parse_position_expr(&mut self) -> Result<Expr<Raw>, ParserError>

fn parse_literal_interval(&mut self) -> Result<Expr<Raw>, ParserError>

Parse an INTERVAL literal.

Some syntactically valid intervals:

1. INTERVAL '1' DAY
2. INTERVAL '1-1' YEAR TO MONTH
3. INTERVAL '1' SECOND
4. `INTERVAL ‘1:1’ MINUTE TO SECOND
5. INTERVAL '1:1:1.1' HOUR TO SECOND (5)
6. INTERVAL '1.111' SECOND (2)

fn parse_infix(
    &mut self,
    expr: Expr<Raw>,
    precedence: Precedence
) -> Result<Expr<Raw>, ParserError>

Parse an operator following an expression

fn parse_subscript(&mut self, expr: Expr<Raw>) -> Result<Expr<Raw>, ParserError>

Parse subscript expression, i.e. either an index value or slice range.

fn parse_substring_expr(&mut self) -> Result<Expr<Raw>, ParserError>

fn parse_operator_name(&mut self) -> Result<Op, ParserError>

Parse a possibly qualified, possibly quoted operator, e.g. +, pg_catalog.+, or "pg_catalog".+

fn parse_in(
    &mut self,
    expr: Expr<Raw>,
    negated: bool
) -> Result<Expr<Raw>, ParserError>

Parses the parens following the [ NOT ] IN operator

fn parse_between(
    &mut self,
    expr: Expr<Raw>,
    negated: bool
) -> Result<Expr<Raw>, ParserError>

Parses BETWEEN <low> AND <high>, assuming the BETWEEN keyword was already consumed

fn parse_pg_cast(&mut self, expr: Expr<Raw>) -> Result<Expr<Raw>, ParserError>

Parse a postgresql casting style which is in the form of expr::datatype

fn get_next_precedence(&self) -> Precedence

Get the precedence of the next token

fn peek_token(&self) -> Option<Token>

Return the first non-whitespace token that has not yet been processed (or None if reached end-of-file)

fn peek_keyword(&mut self, kw: Keyword) -> bool

fn peek_keywords(&mut self, keywords: &[Keyword]) -> bool

fn peek_nth_token(&self, n: usize) -> Option<Token>

Return the nth token that has not yet been processed.

fn next_token(&mut self) -> Option<Token>

Return the next token that has not yet been processed, or None if reached end-of-file, and mark it as processed. OK to call repeatedly after reaching EOF.

fn prev_token(&mut self)

Push back the last one non-whitespace token. Must be called after next_token(), otherwise might panic. OK to call after next_token() indicates an EOF.

fn peek_pos(&self) -> usize

Return the byte position within the query string at which the next token starts.

fn peek_prev_pos(&self) -> usize

Return the byte position within the query string at which the previous token starts.

Must be called after next_token(), otherwise might panic. OK to call after next_token() indicates an EOF.

fn expected<D, T>(
    &self,
    pos: usize,
    expected: D,
    found: Option<Token>
) -> Result<T, ParserError> where
    D: Display, 

Report unexpected token

fn parse_keyword(&mut self, kw: Keyword) -> bool

Look for an expected keyword and consume it if it exists

fn parse_keywords(&mut self, keywords: &[Keyword]) -> bool

Look for an expected sequence of keywords and consume them if they exist

fn parse_at_most_one_keyword(
    &mut self,
    keywords: &[Keyword],
    location: &str
) -> Result<Option<Keyword>, ParserError>

fn parse_one_of_keywords(&mut self, kws: &[Keyword]) -> Option<Keyword>

Look for one of the given keywords and return the one that matches.

fn expect_one_of_keywords(
    &mut self,
    keywords: &[Keyword]
) -> Result<Keyword, ParserError>

Bail out if the current token is not one of the expected keywords, or consume it if it is

fn expect_keyword(&mut self, expected: Keyword) -> Result<(), ParserError>

Bail out if the current token is not an expected keyword, or consume it if it is

fn expect_keywords(&mut self, expected: &[Keyword]) -> Result<(), ParserError>

Bail out if the following tokens are not the expected sequence of keywords, or consume them if they are.

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

Consume the next token if it matches the expected token, otherwise return false

fn expect_token(&mut self, expected: &Token) -> Result<(), ParserError>

Bail out if the current token is not an expected keyword, or consume it if it is

fn parse_comma_separated<T, F>(&mut self, f: F) -> Result<Vec<T>, ParserError> where
    F: FnMut(&mut Self) -> Result<T, ParserError>, 

Parse a comma-separated list of 1+ items accepted by F

fn maybe_parse<T, F>(&mut self, f: F) -> Option<T> where
    F: FnMut(&mut Self) -> Result<T, ParserError>, 

fn parse_create(&mut self) -> Result<Statement<Raw>, ParserError>

Parse a SQL CREATE statement

fn parse_create_database(&mut self) -> Result<Statement<Raw>, ParserError>

fn parse_create_schema(&mut self) -> Result<Statement<Raw>, ParserError>

fn parse_format(&mut self) -> Result<Format<Raw>, ParserError>

fn parse_avro_schema(&mut self) -> Result<AvroSchema<Raw>, ParserError>

fn parse_protobuf_schema(&mut self) -> Result<ProtobufSchema<Raw>, ParserError>

fn parse_csr_connector_avro(
    &mut self
) -> Result<CsrConnectorAvro<Raw>, ParserError>

fn parse_csr_connector_proto(
    &mut self
) -> Result<CsrConnectorProto<Raw>, ParserError>

fn parse_schema(&mut self) -> Result<Schema, ParserError>

fn parse_envelope(&mut self) -> Result<Envelope, ParserError>

fn parse_compression(&mut self) -> Result<Compression, ParserError>

fn parse_create_source(&mut self) -> Result<Statement<Raw>, ParserError>

fn parse_source_columns(
    &mut self
) -> Result<(Vec<Ident>, Option<KeyConstraint>), ParserError>

Parses the column section of a CREATE SOURCE statement which can be empty or a comma-separated list of column identifiers and a single key constraint, e.g.

(col_0, col_i, …, col_n, key_constraint)

fn parse_key_constraint(&mut self) -> Result<Option<KeyConstraint>, ParserError>

Parses a key constraint.

fn parse_create_sink(&mut self) -> Result<Statement<Raw>, ParserError>

fn parse_create_source_connector(
    &mut self
) -> Result<CreateSourceConnector, ParserError>

fn parse_create_sink_connector(
    &mut self
) -> Result<CreateSinkConnector<Raw>, ParserError>

fn parse_kafka_consistency(
    &mut self
) -> Result<Option<KafkaConsistency<Raw>>, ParserError>

fn parse_create_view(&mut self) -> Result<Statement<Raw>, ParserError>

fn parse_view_definition(&mut self) -> Result<ViewDefinition<Raw>, ParserError>

fn parse_create_views(&mut self) -> Result<Statement<Raw>, ParserError>

fn parse_create_index(&mut self) -> Result<Statement<Raw>, ParserError>

fn parse_create_role(&mut self) -> Result<Statement<Raw>, ParserError>

fn parse_create_type(&mut self) -> Result<Statement<Raw>, ParserError>

fn parse_data_type_option(&mut self) -> Result<SqlOption<Raw>, ParserError>

fn parse_if_exists(&mut self) -> Result<bool, ParserError>

fn parse_if_not_exists(&mut self) -> Result<bool, ParserError>

fn parse_source_include_metadata(
    &mut self
) -> Result<Vec<SourceIncludeMetadata>, ParserError>

fn parse_discard(&mut self) -> Result<Statement<Raw>, ParserError>

fn parse_drop(&mut self) -> Result<Statement<Raw>, ParserError>

fn parse_create_table(&mut self) -> Result<Statement<Raw>, ParserError>

fn parse_columns(
    &mut self,
    optional: IsOptional
) -> Result<(Vec<ColumnDef<Raw>>, Vec<TableConstraint<Raw>>), ParserError>

fn parse_column_option_def(
    &mut self
) -> Result<ColumnOptionDef<Raw>, ParserError>

fn parse_optional_table_constraint(
    &mut self
) -> Result<Option<TableConstraint<Raw>>, ParserError>

fn parse_opt_with_sql_options(
    &mut self
) -> Result<Vec<SqlOption<Raw>>, ParserError>

fn parse_options(&mut self) -> Result<Vec<SqlOption<Raw>>, ParserError>

fn parse_sql_option(&mut self) -> Result<SqlOption<Raw>, ParserError>

fn parse_opt_with_options(&mut self) -> Result<Vec<WithOption>, ParserError>

fn parse_with_options(
    &mut self,
    require_equals: bool
) -> Result<Vec<WithOption>, ParserError>

fn parse_with_option(
    &mut self,
    require_equals: bool
) -> Result<WithOption, ParserError>

If require_equals is true, parse options of the form KEY = VALUE or just KEY. If require_equals is false, additionally support KEY VALUE (but still the others).

fn parse_alter(&mut self) -> Result<Statement<Raw>, ParserError>

fn parse_copy(&mut self) -> Result<Statement<Raw>, ParserError>

Parse a copy statement

fn parse_value(&mut self) -> Result<Value, ParserError>

Parse a literal value (numbers, strings, date/time, booleans)

fn parse_boolean_value(&mut self) -> Result<bool, ParserError>

fn parse_value_array(&mut self) -> Result<Value, ParserError>

fn parse_array(&mut self) -> Result<Expr<Raw>, ParserError>

fn parse_list(&mut self) -> Result<Expr<Raw>, ParserError>

fn parse_sequence<F>(&mut self, f: F) -> Result<Vec<Expr<Raw>>, ParserError> where
    F: FnMut(&mut Self) -> Result<Expr<Raw>, ParserError>, 

fn parse_number_value(&mut self) -> Result<Value, ParserError>

fn parse_literal_uint(&mut self) -> Result<u64, ParserError>

Parse an unsigned literal integer/long

fn parse_literal_string(&mut self) -> Result<String, ParserError>

Parse a literal string

fn parse_data_type(&mut self) -> Result<DataType<Raw>, ParserError>

Parse a SQL datatype (in the context of a CREATE TABLE statement for example)

fn parse_typ_mod(&mut self) -> Result<Vec<u64>, ParserError>

fn parse_optional_alias<F>(
    &mut self,
    is_reserved: F
) -> Result<Option<Ident>, ParserError> where
    F: FnOnce(Keyword) -> bool, 

Parse AS identifier (or simply identifier if it’s not a reserved keyword) Some examples with aliases: SELECT 1 foo, SELECT COUNT(*) AS cnt, SELECT ... FROM t1 foo, t2 bar, SELECT ... FROM (...) AS bar

fn parse_optional_table_alias(
    &mut self
) -> Result<Option<TableAlias>, ParserError>

Parse AS identifier when the AS is describing a table-valued object, like in ... FROM generate_series(1, 10) AS t (col). In this case the alias is allowed to optionally name the columns in the table, in addition to the table itself.

fn parse_object_name(&mut self) -> Result<UnresolvedObjectName, ParserError>

Parse a possibly qualified, possibly quoted identifier, e.g. foo or myschema."table"

fn parse_identifier(&mut self) -> Result<Ident, ParserError>

Parse a simple one-word identifier (possibly quoted, possibly a keyword)

fn consume_identifier(&mut self) -> Option<Ident>

fn parse_qualified_identifier(
    &mut self,
    id: Ident
) -> Result<Expr<Raw>, ParserError>

fn parse_parenthesized_column_list(
    &mut self,
    optional: IsOptional
) -> Result<Vec<Ident>, ParserError>

Parse a parenthesized comma-separated list of unqualified, possibly quoted identifiers

fn parse_optional_precision(&mut self) -> Result<Option<u64>, ParserError>

fn parse_map(&mut self) -> Result<DataType<Raw>, ParserError>

fn parse_delete(&mut self) -> Result<Statement<Raw>, ParserError>

fn parse_query(&mut self) -> Result<Query<Raw>, ParserError>

Parse a query expression, i.e. a SELECT statement optionally preceeded with some WITH CTE declarations and optionally followed by ORDER BY. Unlike some other parse_… methods, this one doesn’t expect the initial keyword to be already consumed

fn parse_query_tail(
    &mut self,
    ctes: Vec<Cte<Raw>>,
    body: SetExpr<Raw>
) -> Result<Query<Raw>, ParserError>

fn parse_cte(&mut self) -> Result<Cte<Raw>, ParserError>

Parse a CTE (alias [( col1, col2, ... )] AS (subquery))

fn parse_query_body(
    &mut self,
    precedence: SetPrecedence
) -> Result<SetExpr<Raw>, ParserError>

Parse a “query body”, which is an expression with roughly the following grammar:

  query_body ::= restricted_select | '(' subquery ')' | set_operation
  restricted_select ::= 'SELECT' [expr_list] [ from ] [ where ] [ groupby_having ]
  subquery ::= query_body [ order_by_limit ]
  set_operation ::= query_body { 'UNION' | 'EXCEPT' | 'INTERSECT' } [ 'ALL' ] query_body

fn parse_query_body_seeded(
    &mut self,
    precedence: SetPrecedence,
    expr: SetExpr<Raw>
) -> Result<SetExpr<Raw>, ParserError>

fn parse_set_operator(&mut self, token: &Option<Token>) -> Option<SetOperator>

fn parse_select(&mut self) -> Result<Select<Raw>, ParserError>

Parse a restricted SELECT statement (no CTEs / UNION / ORDER BY), assuming the initial SELECT was already consumed

fn parse_set(&mut self) -> Result<Statement<Raw>, ParserError>

fn parse_show(&mut self) -> Result<Statement<Raw>, ParserError>

fn parse_show_columns(
    &mut self,
    extended: bool,
    full: bool
) -> Result<Statement<Raw>, ParserError>

fn parse_show_statement_filter(
    &mut self
) -> Result<Option<ShowStatementFilter<Raw>>, ParserError>

fn parse_table_and_joins(&mut self) -> Result<TableWithJoins<Raw>, ParserError>

fn parse_table_factor(&mut self) -> Result<TableFactor<Raw>, ParserError>

A table name or a parenthesized subquery, followed by optional [AS] alias

fn parse_rows_from(&mut self) -> Result<TableFactor<Raw>, ParserError>

fn parse_table_function(&mut self) -> Result<TableFunction<Raw>, ParserError>

fn parse_derived_table_factor(
    &mut self,
    lateral: IsLateral
) -> Result<TableFactor<Raw>, ParserError>

fn parse_join_constraint(
    &mut self,
    natural: bool
) -> Result<JoinConstraint<Raw>, ParserError>

fn parse_insert(&mut self) -> Result<Statement<Raw>, ParserError>

Parse an INSERT statement

fn parse_update(&mut self) -> Result<Statement<Raw>, ParserError>

fn parse_assignment(&mut self) -> Result<Assignment<Raw>, ParserError>

Parse a var = expr assignment, used in an UPDATE statement

fn parse_optional_args(
    &mut self,
    allow_order_by: bool
) -> Result<FunctionArgs<Raw>, ParserError>

fn parse_optional_as_of(&mut self) -> Result<Option<Expr<Raw>>, ParserError>

Parse AS OF, if present.

fn parse_select_item(&mut self) -> Result<SelectItem<Raw>, ParserError>

Parse a comma-delimited list of projections after SELECT

fn parse_order_by_expr(&mut self) -> Result<OrderByExpr<Raw>, ParserError>

Parse an expression, optionally followed by ASC or DESC (used in ORDER BY)

fn parse_values(&mut self) -> Result<Values<Raw>, ParserError>

fn parse_start_transaction(&mut self) -> Result<Statement<Raw>, ParserError>

fn parse_begin(&mut self) -> Result<Statement<Raw>, ParserError>

fn parse_transaction_modes(
    &mut self
) -> Result<Vec<TransactionMode>, ParserError>

fn parse_commit(&mut self) -> Result<Statement<Raw>, ParserError>

fn parse_rollback(&mut self) -> Result<Statement<Raw>, ParserError>

fn parse_commit_rollback_chain(&mut self) -> Result<bool, ParserError>

fn parse_tail(&mut self) -> Result<Statement<Raw>, ParserError>

fn parse_explain(&mut self) -> Result<Statement<Raw>, ParserError>

Parse an EXPLAIN statement, assuming that the EXPLAIN token has already been consumed.

fn parse_declare(&mut self) -> Result<Statement<Raw>, ParserError>

Parse a DECLARE statement, assuming that the DECLARE token has already been consumed.

fn parse_close(&mut self) -> Result<Statement<Raw>, ParserError>

Parse a CLOSE statement, assuming that the CLOSE token has already been consumed.

fn parse_prepare(&mut self) -> Result<Statement<Raw>, ParserError>

Parse a PREPARE statement, assuming that the PREPARE token has already been consumed.

fn parse_execute(&mut self) -> Result<Statement<Raw>, ParserError>

Parse a EXECUTE statement, assuming that the EXECUTE token has already been consumed.

fn parse_deallocate(&mut self) -> Result<Statement<Raw>, ParserError>

Parse a DEALLOCATE statement, assuming that the DEALLOCATE token has already been consumed.

fn parse_fetch(&mut self) -> Result<Statement<Raw>, ParserError>

Parse a FETCH statement, assuming that the FETCH token has already been consumed.

Trait Implementations

impl CheckedRecursion for Parser<'_>

fn recursion_guard(&self) -> &RecursionGuard

Extracts a reference to the recursion guard embedded within the type.

fn checked_recur<F, T, E>(&self, f: F) -> Result<T, E> where
    F: FnOnce(&Self) -> Result<T, E>,
    E: From<RecursionLimitError>, 

Checks whether it is safe to recur and calls f if so.

fn checked_recur_mut<F, T, E>(&mut self, f: F) -> Result<T, E> where
    F: FnOnce(&mut Self) -> Result<T, E>,
    E: From<RecursionLimitError>, 

Like CheckedRecursion::checked_recur, but operates on a mutable reference to Self.