pub struct Parser<'a> { /* private fields */ }
Implementations
sourceimpl<'a> Parser<'a>
impl<'a> Parser<'a>
sourcepub fn parse_sql(
dialect: &dyn Dialect,
sql: &str
) -> Result<Vec<Statement>, ParserError>
pub fn parse_sql(
dialect: &dyn Dialect,
sql: &str
) -> Result<Vec<Statement>, ParserError>
Parse a SQL statement and produce an Abstract Syntax Tree (AST)
sourcepub fn parse_statement(&mut self) -> Result<Statement, ParserError>
pub fn parse_statement(&mut self) -> Result<Statement, ParserError>
Parse a single top-level statement (such as SELECT, INSERT, CREATE, etc.), stopping before the statement separator, if any.
pub fn parse_msck(&mut self) -> Result<Statement, ParserError>
pub fn parse_truncate(&mut self) -> Result<Statement, ParserError>
pub fn parse_analyze(&mut self) -> Result<Statement, ParserError>
sourcepub fn parse_wildcard_expr(&mut self) -> Result<WildcardExpr, ParserError>
pub fn parse_wildcard_expr(&mut self) -> Result<WildcardExpr, ParserError>
Parse a new expression including wildcard & qualified wildcard
sourcepub fn parse_expr(&mut self) -> Result<Expr, ParserError>
pub fn parse_expr(&mut self) -> Result<Expr, ParserError>
Parse a new expression
sourcepub fn parse_subexpr(&mut self, precedence: u8) -> Result<Expr, ParserError>
pub fn parse_subexpr(&mut self, precedence: u8) -> Result<Expr, ParserError>
Parse tokens until the precedence changes
pub fn parse_assert(&mut self) -> Result<Statement, ParserError>
pub fn parse_savepoint(&mut self) -> Result<Statement, ParserError>
sourcepub fn parse_prefix(&mut self) -> Result<Expr, ParserError>
pub fn parse_prefix(&mut self) -> Result<Expr, ParserError>
Parse an expression prefix
pub fn parse_function(&mut self, name: ObjectName) -> Result<Expr, ParserError>
pub fn parse_time_functions(
&mut self,
name: ObjectName
) -> Result<Expr, ParserError>
pub fn parse_window_frame_units(
&mut self
) -> Result<WindowFrameUnits, ParserError>
pub fn parse_window_frame(&mut self) -> Result<WindowFrame, ParserError>
sourcepub fn parse_window_frame_bound(
&mut self
) -> Result<WindowFrameBound, ParserError>
pub fn parse_window_frame_bound(
&mut self
) -> Result<WindowFrameBound, ParserError>
Parse CURRENT ROW
or { <positive number> | UNBOUNDED } { PRECEDING | FOLLOWING }
pub fn parse_case_expr(&mut self) -> Result<Expr, ParserError>
sourcepub fn parse_cast_expr(&mut self) -> Result<Expr, ParserError>
pub fn parse_cast_expr(&mut self) -> Result<Expr, ParserError>
Parse a SQL CAST function e.g. CAST(expr AS FLOAT)
sourcepub fn parse_try_cast_expr(&mut self) -> Result<Expr, ParserError>
pub fn parse_try_cast_expr(&mut self) -> Result<Expr, ParserError>
Parse a SQL TRY_CAST function e.g. TRY_CAST(expr AS FLOAT)
sourcepub fn parse_exists_expr(&mut self) -> Result<Expr, ParserError>
pub fn parse_exists_expr(&mut self) -> Result<Expr, ParserError>
Parse a SQL EXISTS expression e.g. WHERE EXISTS(SELECT ...)
.
pub fn parse_extract_expr(&mut self) -> Result<Expr, ParserError>
pub fn parse_position_expr(&mut self) -> Result<Expr, ParserError>
pub fn parse_substring_expr(&mut self) -> Result<Expr, ParserError>
sourcepub fn parse_trim_expr(&mut self) -> Result<Expr, ParserError>
pub fn parse_trim_expr(&mut self) -> Result<Expr, ParserError>
TRIM (WHERE ‘text’ FROM ‘text’)
TRIM (‘text’)
pub fn parse_trim_where(&mut self) -> Result<TrimWhereField, ParserError>
sourcepub fn parse_array_expr(&mut self, named: bool) -> Result<Expr, ParserError>
pub fn parse_array_expr(&mut self, named: bool) -> Result<Expr, ParserError>
Parses an array expression [ex1, ex2, ..]
if named
is true
, came from an expression like ARRAY[ex1, ex2]
sourcepub fn parse_listagg_expr(&mut self) -> Result<Expr, ParserError>
pub fn parse_listagg_expr(&mut self) -> Result<Expr, ParserError>
Parse a SQL LISTAGG expression, e.g. LISTAGG(...) WITHIN GROUP (ORDER BY ...)
.
pub fn parse_date_time_field(&mut self) -> Result<DateTimeField, ParserError>
sourcepub fn parse_literal_interval(&mut self) -> Result<Expr, ParserError>
pub fn parse_literal_interval(&mut self) -> Result<Expr, ParserError>
Parse an INTERVAL literal.
Some syntactically valid intervals:
INTERVAL '1' DAY
INTERVAL '1-1' YEAR TO MONTH
INTERVAL '1' SECOND
INTERVAL '1:1:1.1' HOUR (5) TO SECOND (5)
INTERVAL '1.1' SECOND (2, 2)
INTERVAL '1:1' HOUR (5) TO MINUTE (5)
Note that we do not currently attempt to parse the quoted value.
sourcepub fn parse_infix(
&mut self,
expr: Expr,
precedence: u8
) -> Result<Expr, ParserError>
pub fn parse_infix(
&mut self,
expr: Expr,
precedence: u8
) -> Result<Expr, ParserError>
Parse an operator following an expression
pub fn parse_array_index(&mut self, expr: Expr) -> Result<Expr, ParserError>
pub fn parse_map_access(&mut self, expr: Expr) -> Result<Expr, ParserError>
sourcepub fn parse_in(
&mut self,
expr: Expr,
negated: bool
) -> Result<Expr, ParserError>
pub fn parse_in(
&mut self,
expr: Expr,
negated: bool
) -> Result<Expr, ParserError>
Parses the parens following the [ NOT ] IN
operator
sourcepub fn parse_between(
&mut self,
expr: Expr,
negated: bool
) -> Result<Expr, ParserError>
pub fn parse_between(
&mut self,
expr: Expr,
negated: bool
) -> Result<Expr, ParserError>
Parses BETWEEN <low> AND <high>
, assuming the BETWEEN
keyword was already consumed
sourcepub fn parse_pg_cast(&mut self, expr: Expr) -> Result<Expr, ParserError>
pub fn parse_pg_cast(&mut self, expr: Expr) -> Result<Expr, ParserError>
Parse a postgresql casting style which is in the form of expr::datatype
sourcepub fn get_next_precedence(&self) -> Result<u8, ParserError>
pub fn get_next_precedence(&self) -> Result<u8, ParserError>
Get the precedence of the next token
sourcepub fn peek_token(&self) -> Token
pub fn peek_token(&self) -> Token
Return the first non-whitespace token that has not yet been processed (or None if reached end-of-file)
sourcepub fn peek_nth_token(&self, n: usize) -> Token
pub fn peek_nth_token(&self, n: usize) -> Token
Return nth non-whitespace token that has not yet been processed
sourcepub fn next_token(&mut self) -> Token
pub fn next_token(&mut self) -> Token
Return the first non-whitespace 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.
sourcepub fn next_token_no_skip(&mut self) -> Option<&Token>
pub fn next_token_no_skip(&mut self) -> Option<&Token>
Return the first unprocessed token, possibly whitespace.
sourcepub fn prev_token(&mut self)
pub 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.
sourcepub fn parse_keyword(&mut self, expected: Keyword) -> bool
pub fn parse_keyword(&mut self, expected: Keyword) -> bool
Look for an expected keyword and consume it if it exists
sourcepub fn parse_keywords(&mut self, keywords: &[Keyword]) -> bool
pub fn parse_keywords(&mut self, keywords: &[Keyword]) -> bool
Look for an expected sequence of keywords and consume them if they exist
sourcepub fn parse_one_of_keywords(&mut self, keywords: &[Keyword]) -> Option<Keyword>
pub fn parse_one_of_keywords(&mut self, keywords: &[Keyword]) -> Option<Keyword>
Look for one of the given keywords and return the one that matches.
sourcepub fn expect_one_of_keywords(
&mut self,
keywords: &[Keyword]
) -> Result<Keyword, ParserError>
pub 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
sourcepub fn expect_keyword(&mut self, expected: Keyword) -> Result<(), ParserError>
pub 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
sourcepub fn expect_keywords(
&mut self,
expected: &[Keyword]
) -> Result<(), ParserError>
pub 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.
sourcepub fn consume_token(&mut self, expected: &Token) -> bool
pub fn consume_token(&mut self, expected: &Token) -> bool
Consume the next token if it matches the expected token, otherwise return false
sourcepub fn expect_token(&mut self, expected: &Token) -> Result<(), ParserError>
pub 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
sourcepub fn parse_comma_separated<T, F>(
&mut self,
f: F
) -> Result<Vec<T>, ParserError> where
F: FnMut(&mut Parser<'a>) -> Result<T, ParserError>,
pub fn parse_comma_separated<T, F>(
&mut self,
f: F
) -> Result<Vec<T>, ParserError> where
F: FnMut(&mut Parser<'a>) -> Result<T, ParserError>,
Parse a comma-separated list of 1+ items accepted by F
sourcepub fn parse_all_or_distinct(&mut self) -> Result<bool, ParserError>
pub fn parse_all_or_distinct(&mut self) -> Result<bool, ParserError>
Parse either ALL
or DISTINCT
. Returns true
if DISTINCT
is parsed and results in a
ParserError
if both ALL
and DISTINCT
are fround.
sourcepub fn parse_create(&mut self) -> Result<Statement, ParserError>
pub fn parse_create(&mut self) -> Result<Statement, ParserError>
Parse a SQL CREATE statement
sourcepub fn parse_create_virtual_table(&mut self) -> Result<Statement, ParserError>
pub fn parse_create_virtual_table(&mut self) -> Result<Statement, ParserError>
SQLite-specific CREATE VIRTUAL TABLE
pub fn parse_create_schema(&mut self) -> Result<Statement, ParserError>
pub fn parse_create_database(&mut self) -> Result<Statement, ParserError>
pub fn parse_create_external_table(
&mut self,
or_replace: bool
) -> Result<Statement, ParserError>
pub fn parse_file_format(&mut self) -> Result<FileFormat, ParserError>
pub fn parse_create_view(
&mut self,
or_replace: bool
) -> Result<Statement, ParserError>
pub fn parse_drop(&mut self) -> Result<Statement, ParserError>
pub fn parse_create_index(
&mut self,
unique: bool
) -> Result<Statement, ParserError>
pub fn parse_hive_distribution(
&mut self
) -> Result<HiveDistributionStyle, ParserError>
pub fn parse_hive_formats(&mut self) -> Result<HiveFormat, ParserError>
pub fn parse_row_format(&mut self) -> Result<HiveRowFormat, ParserError>
pub fn parse_create_table(
&mut self,
or_replace: bool,
temporary: bool,
global: Option<bool>
) -> Result<Statement, ParserError>
pub fn parse_columns(
&mut self
) -> Result<(Vec<ColumnDef>, Vec<TableConstraint>), ParserError>
pub fn parse_column_def(&mut self) -> Result<ColumnDef, ParserError>
pub fn parse_optional_column_option(
&mut self
) -> Result<Option<ColumnOption>, ParserError>
pub fn parse_referential_action(
&mut self
) -> Result<ReferentialAction, ParserError>
pub fn parse_optional_table_constraint(
&mut self
) -> Result<Option<TableConstraint>, ParserError>
pub fn parse_options(
&mut self,
keyword: Keyword
) -> Result<Vec<SqlOption>, ParserError>
pub fn parse_sql_option(&mut self) -> Result<SqlOption, ParserError>
pub fn parse_alter(&mut self) -> Result<Statement, ParserError>
sourcepub fn parse_copy(&mut self) -> Result<Statement, ParserError>
pub fn parse_copy(&mut self) -> Result<Statement, ParserError>
Parse a copy statement
sourcepub fn parse_tsv(&mut self) -> Vec<Option<String>>
pub fn parse_tsv(&mut self) -> Vec<Option<String>>
Parse a tab separated values in COPY payload
pub fn parse_tab_value(&mut self) -> Vec<Option<String>>
sourcepub fn parse_value(&mut self) -> Result<Value, ParserError>
pub fn parse_value(&mut self) -> Result<Value, ParserError>
Parse a literal value (numbers, strings, date/time, booleans)
pub fn parse_number_value(&mut self) -> Result<Value, ParserError>
sourcepub fn parse_literal_uint(&mut self) -> Result<u64, ParserError>
pub fn parse_literal_uint(&mut self) -> Result<u64, ParserError>
Parse an unsigned literal integer/long
sourcepub fn parse_literal_string(&mut self) -> Result<String, ParserError>
pub fn parse_literal_string(&mut self) -> Result<String, ParserError>
Parse a literal string
sourcepub fn parse_map_key(&mut self) -> Result<Expr, ParserError>
pub fn parse_map_key(&mut self) -> Result<Expr, ParserError>
Parse a map key string
sourcepub fn parse_data_type(&mut self) -> Result<DataType, ParserError>
pub fn parse_data_type(&mut self) -> Result<DataType, ParserError>
Parse a SQL datatype (in the context of a CREATE TABLE statement for example)
pub fn parse_string_values(&mut self) -> Result<Vec<String>, ParserError>
sourcepub fn parse_optional_alias(
&mut self,
reserved_kwds: &[Keyword]
) -> Result<Option<Ident>, ParserError>
pub fn parse_optional_alias(
&mut self,
reserved_kwds: &[Keyword]
) -> Result<Option<Ident>, ParserError>
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
sourcepub fn parse_optional_table_alias(
&mut self,
reserved_kwds: &[Keyword]
) -> Result<Option<TableAlias>, ParserError>
pub fn parse_optional_table_alias(
&mut self,
reserved_kwds: &[Keyword]
) -> 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.
sourcepub fn parse_object_name(&mut self) -> Result<ObjectName, ParserError>
pub fn parse_object_name(&mut self) -> Result<ObjectName, ParserError>
Parse a possibly qualified, possibly quoted identifier, e.g.
foo
or `myschema.“table”
sourcepub fn parse_identifiers_non_keywords(
&mut self
) -> Result<Vec<Ident>, ParserError>
pub fn parse_identifiers_non_keywords(
&mut self
) -> Result<Vec<Ident>, ParserError>
Parse identifiers strictly i.e. don’t parse keywords
sourcepub fn parse_identifiers(&mut self) -> Result<Vec<Ident>, ParserError>
pub fn parse_identifiers(&mut self) -> Result<Vec<Ident>, ParserError>
Parse identifiers
sourcepub fn parse_identifier(&mut self) -> Result<Ident, ParserError>
pub fn parse_identifier(&mut self) -> Result<Ident, ParserError>
Parse a simple one-word identifier (possibly quoted, possibly a keyword)
sourcepub fn parse_parenthesized_column_list(
&mut self,
optional: IsOptional
) -> Result<Vec<Ident>, ParserError>
pub fn parse_parenthesized_column_list(
&mut self,
optional: IsOptional
) -> Result<Vec<Ident>, ParserError>
Parse a parenthesized comma-separated list of unqualified, possibly quoted identifiers
pub fn parse_optional_precision(&mut self) -> Result<Option<u64>, ParserError>
pub fn parse_optional_precision_scale(
&mut self
) -> Result<(Option<u64>, Option<u64>), ParserError>
pub fn parse_delete(&mut self) -> Result<Statement, ParserError>
pub fn parse_kill(&mut self) -> Result<Statement, ParserError>
pub fn parse_explain(
&mut self,
describe_alias: bool
) -> Result<Statement, ParserError>
sourcepub fn parse_query(&mut self) -> Result<Query, ParserError>
pub fn parse_query(&mut self) -> Result<Query, 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
sourcepub fn parse_cte(&mut self) -> Result<Cte, ParserError>
pub fn parse_cte(&mut self) -> Result<Cte, ParserError>
Parse a CTE (alias [( col1, col2, ... )] AS (subquery)
)
sourcepub fn parse_query_body(
&mut self,
precedence: u8
) -> Result<SetExpr, ParserError>
pub fn parse_query_body(
&mut self,
precedence: u8
) -> Result<SetExpr, 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
pub fn parse_set_operator(&mut self, token: &Token) -> Option<SetOperator>
sourcepub fn parse_select(&mut self) -> Result<Select, ParserError>
pub fn parse_select(&mut self) -> Result<Select, ParserError>
Parse a restricted SELECT
statement (no CTEs / UNION
/ ORDER BY
),
assuming the initial SELECT
was already consumed
pub fn parse_set(&mut self) -> Result<Statement, ParserError>
pub fn parse_show(&mut self) -> Result<Statement, ParserError>
pub fn parse_show_create(&mut self) -> Result<Statement, ParserError>
pub fn parse_show_columns(&mut self) -> Result<Statement, ParserError>
pub fn parse_show_statement_filter(
&mut self
) -> Result<Option<ShowStatementFilter>, ParserError>
pub fn parse_table_and_joins(&mut self) -> Result<TableWithJoins, ParserError>
sourcepub fn parse_table_factor(&mut self) -> Result<TableFactor, ParserError>
pub fn parse_table_factor(&mut self) -> Result<TableFactor, ParserError>
A table name or a parenthesized subquery, followed by optional [AS] alias
pub fn parse_derived_table_factor(
&mut self,
lateral: IsLateral
) -> Result<TableFactor, ParserError>
pub fn parse_join_constraint(
&mut self,
natural: bool
) -> Result<JoinConstraint, ParserError>
sourcepub fn parse_grant(&mut self) -> Result<Statement, ParserError>
pub fn parse_grant(&mut self) -> Result<Statement, ParserError>
Parse a GRANT statement.
pub fn parse_grant_revoke_privileges_objects(
&mut self
) -> Result<(Privileges, GrantObjects), ParserError>
pub fn parse_grant_permission(
&mut self
) -> Result<(Keyword, Option<Vec<Ident>>), ParserError>
sourcepub fn parse_revoke(&mut self) -> Result<Statement, ParserError>
pub fn parse_revoke(&mut self) -> Result<Statement, ParserError>
Parse a REVOKE statement
sourcepub fn parse_insert(&mut self) -> Result<Statement, ParserError>
pub fn parse_insert(&mut self) -> Result<Statement, ParserError>
Parse an INSERT statement
pub fn parse_update(&mut self) -> Result<Statement, ParserError>
sourcepub fn parse_assignment(&mut self) -> Result<Assignment, ParserError>
pub fn parse_assignment(&mut self) -> Result<Assignment, ParserError>
Parse a var = expr
assignment, used in an UPDATE statement
pub fn parse_function_args(&mut self) -> Result<FunctionArg, ParserError>
pub fn parse_optional_args(&mut self) -> Result<Vec<FunctionArg>, ParserError>
sourcepub fn parse_select_item(&mut self) -> Result<SelectItem, ParserError>
pub fn parse_select_item(&mut self) -> Result<SelectItem, ParserError>
Parse a comma-delimited list of projections after SELECT
sourcepub fn parse_order_by_expr(&mut self) -> Result<OrderByExpr, ParserError>
pub fn parse_order_by_expr(&mut self) -> Result<OrderByExpr, ParserError>
Parse an expression, optionally followed by ASC or DESC (used in ORDER BY)
sourcepub fn parse_top(&mut self) -> Result<Top, ParserError>
pub fn parse_top(&mut self) -> Result<Top, ParserError>
Parse a TOP clause, MSSQL equivalent of LIMIT, that follows after SELECT [DISTINCT].
sourcepub fn parse_limit(&mut self) -> Result<Option<Expr>, ParserError>
pub fn parse_limit(&mut self) -> Result<Option<Expr>, ParserError>
Parse a LIMIT clause
sourcepub fn parse_offset(&mut self) -> Result<Offset, ParserError>
pub fn parse_offset(&mut self) -> Result<Offset, ParserError>
Parse an OFFSET clause
sourcepub fn parse_fetch(&mut self) -> Result<Fetch, ParserError>
pub fn parse_fetch(&mut self) -> Result<Fetch, ParserError>
Parse a FETCH clause
sourcepub fn parse_lock(&mut self) -> Result<LockType, ParserError>
pub fn parse_lock(&mut self) -> Result<LockType, ParserError>
Parse a FOR UPDATE/FOR SHARE clause
pub fn parse_values(&mut self) -> Result<Values, ParserError>
pub fn parse_start_transaction(&mut self) -> Result<Statement, ParserError>
pub fn parse_begin(&mut self) -> Result<Statement, ParserError>
pub fn parse_transaction_modes(
&mut self
) -> Result<Vec<TransactionMode>, ParserError>
pub fn parse_commit(&mut self) -> Result<Statement, ParserError>
pub fn parse_rollback(&mut self) -> Result<Statement, ParserError>
pub fn parse_commit_rollback_chain(&mut self) -> Result<bool, ParserError>
pub fn parse_deallocate(&mut self) -> Result<Statement, ParserError>
pub fn parse_execute(&mut self) -> Result<Statement, ParserError>
pub fn parse_prepare(&mut self) -> Result<Statement, ParserError>
pub fn parse_comment(&mut self) -> Result<Statement, ParserError>
pub fn parse_merge_clauses(&mut self) -> Result<Vec<MergeClause>, ParserError>
pub fn parse_merge(&mut self) -> Result<Statement, ParserError>
Auto Trait Implementations
impl<'a> !RefUnwindSafe for Parser<'a>
impl<'a> !Send for Parser<'a>
impl<'a> !Sync for Parser<'a>
impl<'a> Unpin for Parser<'a>
impl<'a> !UnwindSafe for Parser<'a>
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more