// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

//! SQL Parser

#[cfg(not(feature = "std"))]

use alloc::{

boxed::Box,

format,

string::{String, ToString},

vec,

vec::Vec,

};

use core::fmt;

use log::debug;

use IsLateral::*;

use IsOptional::*;

use crate::ast::helpers::stmt_create_table::CreateTableBuilder;

use crate::ast::*;

use crate::dialect::*;

use crate::keywords::{self, Keyword};

use crate::tokenizer::*;

#[derive(Debug, Clone, PartialEq, Eq)]

pub enum ParserError {

TokenizerError(String),

ParserError(String),

RecursionLimitExceeded,

}

// Use `Parser::expected` instead, if possible

macro_rules! parser_err {

($MSG:expr) => {

Err(ParserError::ParserError($MSG.to_string()))

};

}

// Returns a successful result if the optional expression is some

macro_rules! return_ok_if_some {

($e:expr) => {{

if let Some(v) = $e {

return Ok(v);

}

}};

}

#[cfg(feature = "std")]

/// Implementation [`RecursionCounter`] if std is available

mod recursion {

use core::sync::atomic::{AtomicUsize, Ordering};

use std::rc::Rc;

use super::ParserError;

/// Tracks remaining recursion depth. This value is decremented on

/// each call to `try_decrease()`, when it reaches 0 an error will

/// be returned.

///

/// Note: Uses an Rc and AtomicUsize in order to satisfy the Rust

/// borrow checker so the automatic DepthGuard decrement a

/// reference to the counter. The actual value is not modified

/// concurrently

pub(crate) struct RecursionCounter {

remaining_depth: Rc<AtomicUsize>,

}

impl RecursionCounter {

/// Creates a [`RecursionCounter`] with the specified maximum

/// depth

pub fn new(remaining_depth: usize) -> Self {

Self {

remaining_depth: Rc::new(remaining_depth.into()),

}

}

/// Decreases the remaining depth by 1.

///

/// Returns `Err` if the remaining depth falls to 0.

///

/// Returns a [`DepthGuard`] which will adds 1 to the

/// remaining depth upon drop;

pub fn try_decrease(&self) -> Result<DepthGuard, ParserError> {

let old_value = self.remaining_depth.fetch_sub(1, Ordering::SeqCst);

// ran out of space

if old_value == 0 {

Err(ParserError::RecursionLimitExceeded)

} else {

Ok(DepthGuard::new(Rc::clone(&self.remaining_depth)))

}

}

}

/// Guard that increass the remaining depth by 1 on drop

pub struct DepthGuard {

remaining_depth: Rc<AtomicUsize>,

}

impl DepthGuard {

fn new(remaining_depth: Rc<AtomicUsize>) -> Self {

Self { remaining_depth }

}

}

impl Drop for DepthGuard {

fn drop(&mut self) {

self.remaining_depth.fetch_add(1, Ordering::SeqCst);

}

}

}

#[cfg(not(feature = "std"))]

mod recursion {

/// Implementation [`RecursionCounter`] if std is NOT available (and does not

/// guard against stack overflow).

///

/// Has the same API as the std RecursionCounter implementation

/// but does not actually limit stack depth.

pub(crate) struct RecursionCounter {}

impl RecursionCounter {

pub fn new(_remaining_depth: usize) -> Self {

Self {}

}

pub fn try_decrease(&self) -> Result<DepthGuard, super::ParserError> {

Ok(DepthGuard {})

}

}

pub struct DepthGuard {}

}

use recursion::RecursionCounter;

#[derive(PartialEq, Eq)]

pub enum IsOptional {

Optional,

Mandatory,

}

pub enum IsLateral {

Lateral,

NotLateral,

}

pub enum WildcardExpr {

Expr(Expr),

QualifiedWildcard(ObjectName),

Wildcard,

}

impl From<WildcardExpr> for FunctionArgExpr {

fn from(wildcard_expr: WildcardExpr) -> Self {

match wildcard_expr {

WildcardExpr::Expr(expr) => Self::Expr(expr),

WildcardExpr::QualifiedWildcard(prefix) => Self::QualifiedWildcard(prefix),

WildcardExpr::Wildcard => Self::Wildcard,

}

}

}

impl From<TokenizerError> for ParserError {

fn from(e: TokenizerError) -> Self {

ParserError::TokenizerError(e.to_string())

}

}

impl fmt::Display for ParserError {

fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

write!(

f,

"sql parser error: {}",

match self {

ParserError::TokenizerError(s) => s,

ParserError::ParserError(s) => s,

ParserError::RecursionLimitExceeded => "recursion limit exceeded",

}

)

}

}

#[cfg(feature = "std")]

impl std::error::Error for ParserError {}

// By default, allow expressions up to this deep before erroring

const DEFAULT_REMAINING_DEPTH: usize = 50;

#[derive(Debug, Default, Clone, PartialEq, Eq)]

pub struct ParserOptions {

pub trailing_commas: bool,

}

pub struct Parser<'a> {

tokens: Vec<TokenWithLocation>,

/// The index of the first unprocessed token in `self.tokens`

index: usize,

/// The current dialect to use

dialect: &'a dyn Dialect,

/// Additional options that allow you to mix & match behavior otherwise

/// constrained to certain dialects (e.g. trailing commas)

options: ParserOptions,

/// ensure the stack does not overflow by limiting recursion depth

recursion_counter: RecursionCounter,

}

impl<'a> Parser<'a> {

/// Create a parser for a [`Dialect`]

///

/// See also [`Parser::parse_sql`]

///

/// Example:

/// ```

/// # use sqlparser::{parser::{Parser, ParserError}, dialect::GenericDialect};

/// # fn main() -> Result<(), ParserError> {

/// let dialect = GenericDialect{};

/// let statements = Parser::new(&dialect)

/// .try_with_sql("SELECT * FROM foo")?

/// .parse_statements()?;

/// # Ok(())

/// # }

/// ```

pub fn new(dialect: &'a dyn Dialect) -> Self {

Self {

tokens: vec![],

index: 0,

dialect,

recursion_counter: RecursionCounter::new(DEFAULT_REMAINING_DEPTH),

options: ParserOptions::default(),

}

}

/// Specify the maximum recursion limit while parsing.

///

///

/// [`Parser`] prevents stack overflows by returning

/// [`ParserError::RecursionLimitExceeded`] if the parser exceeds

/// this depth while processing the query.

///

/// Example:

/// ```

/// # use sqlparser::{parser::{Parser, ParserError}, dialect::GenericDialect};

/// # fn main() -> Result<(), ParserError> {

/// let dialect = GenericDialect{};

/// let result = Parser::new(&dialect)

/// .with_recursion_limit(1)

/// .try_with_sql("SELECT * FROM foo WHERE (a OR (b OR (c OR d)))")?

/// .parse_statements();

/// assert_eq!(result, Err(ParserError::RecursionLimitExceeded));

/// # Ok(())

/// # }

/// ```

pub fn with_recursion_limit(mut self, recursion_limit: usize) -> Self {

self.recursion_counter = RecursionCounter::new(recursion_limit);

self

}

/// Specify additional parser options

///

///

/// [`Parser`] supports additional options ([`ParserOptions`]) that allow you to

/// mix & match behavior otherwise constrained to certain dialects (e.g. trailing

/// commas).

///

/// Example:

/// ```

/// # use sqlparser::{parser::{Parser, ParserError, ParserOptions}, dialect::GenericDialect};

/// # fn main() -> Result<(), ParserError> {

/// let dialect = GenericDialect{};

/// let result = Parser::new(&dialect)

/// .with_options(ParserOptions { trailing_commas: true })

/// .try_with_sql("SELECT a, b, COUNT(*), FROM foo GROUP BY a, b,")?

/// .parse_statements();

/// assert!(matches!(result, Ok(_)));

/// # Ok(())

/// # }

/// ```

pub fn with_options(mut self, options: ParserOptions) -> Self {

self.options = options;

self

}

/// Reset this parser to parse the specified token stream

pub fn with_tokens_with_locations(mut self, tokens: Vec<TokenWithLocation>) -> Self {

self.tokens = tokens;

self.index = 0;

self

}

/// Reset this parser state to parse the specified tokens

pub fn with_tokens(self, tokens: Vec<Token>) -> Self {

// Put in dummy locations

let tokens_with_locations: Vec<TokenWithLocation> = tokens

.into_iter()

.map(|token| TokenWithLocation {

token,

location: Location { line: 0, column: 0 },

})

.collect();

self.with_tokens_with_locations(tokens_with_locations)

}

/// Tokenize the sql string and sets this [`Parser`]'s state to

/// parse the resulting tokens

///

/// Returns an error if there was an error tokenizing the SQL string.

///

/// See example on [`Parser::new()`] for an example

pub fn try_with_sql(self, sql: &str) -> Result<Self, ParserError> {

debug!("Parsing sql '{}'...", sql);

let mut tokenizer = Tokenizer::new(self.dialect, sql);

let tokens = tokenizer.tokenize()?;

Ok(self.with_tokens(tokens))

}

/// Parse potentially multiple statements

///

/// Example

/// ```

/// # use sqlparser::{parser::{Parser, ParserError}, dialect::GenericDialect};

/// # fn main() -> Result<(), ParserError> {

/// let dialect = GenericDialect{};

/// let statements = Parser::new(&dialect)

/// // Parse a SQL string with 2 separate statements

/// .try_with_sql("SELECT * FROM foo; SELECT * FROM bar;")?

/// .parse_statements()?;

/// assert_eq!(statements.len(), 2);

/// # Ok(())

/// # }

/// ```

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

let mut stmts = Vec::new();

let mut expecting_statement_delimiter = false;

loop {

// ignore empty statements (between successive statement delimiters)

while self.consume_token(&Token::SemiColon) {

expecting_statement_delimiter = false;

}

match self.peek_token().token {

Token::EOF => break,

// end of statement

Token::Word(word) if word.keyword == Keyword::END => break,

_ => {}

}

if expecting_statement_delimiter {

return self.expected("end of statement", self.peek_token());

}

let statement = self.parse_statement()?;

stmts.push(statement);

expecting_statement_delimiter = true;

}

Ok(stmts)

}

/// Convenience method to parse a string with one or more SQL

/// statements into produce an Abstract Syntax Tree (AST).

///

/// Example

/// ```

/// # use sqlparser::{parser::{Parser, ParserError}, dialect::GenericDialect};

/// # fn main() -> Result<(), ParserError> {

/// let dialect = GenericDialect{};

/// let statements = Parser::parse_sql(

/// &dialect, "SELECT * FROM foo"

/// )?;

/// assert_eq!(statements.len(), 1);

/// # Ok(())

/// # }

/// ```

pub fn parse_sql(dialect: &dyn Dialect, sql: &str) -> Result<Vec<Statement>, ParserError> {

Parser::new(dialect).try_with_sql(sql)?.parse_statements()

}

/// Parse a single top-level statement (such as SELECT, INSERT, CREATE, etc.),

/// stopping before the statement separator, if any.

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

let _guard = self.recursion_counter.try_decrease()?;

// allow the dialect to override statement parsing

if let Some(statement) = self.dialect.parse_statement(self) {

return statement;

}

let next_token = self.next_token();

match &next_token.token {

Token::Word(w) => match w.keyword {

Keyword::KILL => Ok(self.parse_kill()?),

Keyword::DESCRIBE => Ok(self.parse_explain(true)?),

Keyword::EXPLAIN => Ok(self.parse_explain(false)?),

Keyword::ANALYZE => Ok(self.parse_analyze()?),

Keyword::SELECT | Keyword::WITH | Keyword::VALUES => {

self.prev_token();

Ok(Statement::Query(Box::new(self.parse_query()?)))

}

Keyword::TRUNCATE => Ok(self.parse_truncate()?),

Keyword::MSCK => Ok(self.parse_msck()?),

Keyword::CREATE => Ok(self.parse_create()?),

Keyword::CACHE => Ok(self.parse_cache_table()?),

Keyword::DROP => Ok(self.parse_drop()?),

Keyword::DISCARD => Ok(self.parse_discard()?),

Keyword::DECLARE => Ok(self.parse_declare()?),

Keyword::FETCH => Ok(self.parse_fetch_statement()?),

Keyword::DELETE => Ok(self.parse_delete()?),

Keyword::INSERT => Ok(self.parse_insert()?),

Keyword::UNCACHE => Ok(self.parse_uncache_table()?),

Keyword::UPDATE => Ok(self.parse_update()?),

Keyword::ALTER => Ok(self.parse_alter()?),

Keyword::COPY => Ok(self.parse_copy()?),

Keyword::CLOSE => Ok(self.parse_close()?),

Keyword::SET => Ok(self.parse_set()?),

Keyword::SHOW => Ok(self.parse_show()?),

Keyword::USE => Ok(self.parse_use()?),

Keyword::GRANT => Ok(self.parse_grant()?),

Keyword::REVOKE => Ok(self.parse_revoke()?),

Keyword::START => Ok(self.parse_start_transaction()?),

// `BEGIN` is a nonstandard but common alias for the

// standard `START TRANSACTION` statement. It is supported

// by at least PostgreSQL and MySQL.

Keyword::BEGIN => Ok(self.parse_begin()?),

Keyword::SAVEPOINT => Ok(self.parse_savepoint()?),

Keyword::COMMIT => Ok(self.parse_commit()?),

Keyword::ROLLBACK => Ok(self.parse_rollback()?),

Keyword::ASSERT => Ok(self.parse_assert()?),

// `PREPARE`, `EXECUTE` and `DEALLOCATE` are Postgres-specific

// syntaxes. They are used for Postgres prepared statement.

Keyword::DEALLOCATE => Ok(self.parse_deallocate()?),

Keyword::EXECUTE => Ok(self.parse_execute()?),

Keyword::PREPARE => Ok(self.parse_prepare()?),

Keyword::MERGE => Ok(self.parse_merge()?),

_ => self.expected("an SQL statement", next_token),

},

Token::LParen => {

self.prev_token();

Ok(Statement::Query(Box::new(self.parse_query()?)))

}

_ => self.expected("an SQL statement", next_token),

}

}

pub fn parse_msck(&mut self) -> Result<Statement, ParserError> {

let repair = self.parse_keyword(Keyword::REPAIR);

self.expect_keyword(Keyword::TABLE)?;

let table_name = self.parse_object_name()?;

let partition_action = self

.maybe_parse(|parser| {

let pa = match parser.parse_one_of_keywords(&[

Keyword::ADD,

Keyword::DROP,

Keyword::SYNC,

]) {

Some(Keyword::ADD) => Some(AddDropSync::ADD),

Some(Keyword::DROP) => Some(AddDropSync::DROP),

Some(Keyword::SYNC) => Some(AddDropSync::SYNC),

_ => None,

};

parser.expect_keyword(Keyword::PARTITIONS)?;

Ok(pa)

})

.unwrap_or_default();

Ok(Statement::Msck {

repair,

table_name,

partition_action,

})

}

pub fn parse_truncate(&mut self) -> Result<Statement, ParserError> {

let table = self.parse_keyword(Keyword::TABLE);

let table_name = self.parse_object_name()?;

let mut partitions = None;

if self.parse_keyword(Keyword::PARTITION) {

self.expect_token(&Token::LParen)?;

partitions = Some(self.parse_comma_separated(Parser::parse_expr)?);

self.expect_token(&Token::RParen)?;

}

Ok(Statement::Truncate {

table_name,

partitions,

table,

})

}

pub fn parse_analyze(&mut self) -> Result<Statement, ParserError> {

self.expect_keyword(Keyword::TABLE)?;

let table_name = self.parse_object_name()?;

let mut for_columns = false;

let mut cache_metadata = false;

let mut noscan = false;

let mut partitions = None;

let mut compute_statistics = false;

let mut columns = vec![];

loop {

match self.parse_one_of_keywords(&[

Keyword::PARTITION,

Keyword::FOR,

Keyword::CACHE,

Keyword::NOSCAN,

Keyword::COMPUTE,

]) {

Some(Keyword::PARTITION) => {

self.expect_token(&Token::LParen)?;

partitions = Some(self.parse_comma_separated(Parser::parse_expr)?);

self.expect_token(&Token::RParen)?;

}

Some(Keyword::NOSCAN) => noscan = true,

Some(Keyword::FOR) => {

self.expect_keyword(Keyword::COLUMNS)?;

columns = self

.maybe_parse(|parser| {

parser.parse_comma_separated(Parser::parse_identifier)

})

.unwrap_or_default();

for_columns = true

}

Some(Keyword::CACHE) => {

self.expect_keyword(Keyword::METADATA)?;

cache_metadata = true

}

Some(Keyword::COMPUTE) => {

self.expect_keyword(Keyword::STATISTICS)?;

compute_statistics = true

}

_ => break,

}

}

Ok(Statement::Analyze {

table_name,

for_columns,

columns,

partitions,

cache_metadata,

noscan,

compute_statistics,

})

}

/// Parse a new expression including wildcard & qualified wildcard

pub fn parse_wildcard_expr(&mut self) -> Result<WildcardExpr, ParserError> {

let index = self.index;

let next_token = self.next_token();

match next_token.token {

Token::Word(w) if self.peek_token().token == Token::Period => {

let mut id_parts: Vec<Ident> = vec![w.to_ident()];

while self.consume_token(&Token::Period) {

let next_token = self.next_token();

match next_token.token {

Token::Word(w) => id_parts.push(w.to_ident()),

Token::Mul => {

return Ok(WildcardExpr::QualifiedWildcard(ObjectName(id_parts)));

}

_ => {

return self.expected("an identifier or a '*' after '.'", next_token);

}

}

}

}

Token::Mul => {

return Ok(WildcardExpr::Wildcard);

}

_ => (),

};

self.index = index;

self.parse_expr().map(WildcardExpr::Expr)

}

/// Parse a new expression

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

let _guard = self.recursion_counter.try_decrease()?;

self.parse_subexpr(0)

}

/// Parse tokens until the precedence changes

pub fn parse_subexpr(&mut self, precedence: u8) -> Result<Expr, ParserError> {

debug!("parsing expr");

let mut expr = self.parse_prefix()?;

debug!("prefix: {:?}", expr);

loop {

let next_precedence = self.get_next_precedence()?;

debug!("next precedence: {:?}", next_precedence);

if precedence >= next_precedence {

break;

}

expr = self.parse_infix(expr, next_precedence)?;

}

Ok(expr)

}

pub fn parse_interval_expr(&mut self) -> Result<Expr, ParserError> {

let precedence = 0;

let mut expr = self.parse_prefix()?;

loop {

let next_precedence = self.get_next_interval_precedence()?;

if precedence >= next_precedence {

break;

}

expr = self.parse_infix(expr, next_precedence)?;

}

Ok(expr)

}

/// Get the precedence of the next token

/// With AND, OR, and XOR

pub fn get_next_interval_precedence(&self) -> Result<u8, ParserError> {

let token = self.peek_token();

match token.token {

Token::Word(w) if w.keyword == Keyword::AND => Ok(0),

Token::Word(w) if w.keyword == Keyword::OR => Ok(0),

Token::Word(w) if w.keyword == Keyword::XOR => Ok(0),

_ => self.get_next_precedence(),

}

}

pub fn parse_assert(&mut self) -> Result<Statement, ParserError> {

let condition = self.parse_expr()?;

let message = if self.parse_keyword(Keyword::AS) {

Some(self.parse_expr()?)

} else {

None

};

Ok(Statement::Assert { condition, message })

}

pub fn parse_savepoint(&mut self) -> Result<Statement, ParserError> {

let name = self.parse_identifier()?;

Ok(Statement::Savepoint { name })

}

/// Parse an expression prefix

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

// allow the dialect to override prefix parsing

if let Some(prefix) = self.dialect.parse_prefix(self) {

return prefix;

}

// PostgreSQL allows any string literal to be preceded by a type name, indicating that the

// string literal represents a literal of that type. Some examples:

//

// DATE '2020-05-20'

// TIMESTAMP WITH TIME ZONE '2020-05-20 7:43:54'

// BOOL 'true'

//

// The first two are standard SQL, while the latter is a PostgreSQL extension. Complicating

// matters is the fact that INTERVAL string literals may optionally be followed by special

// keywords, e.g.:

//

// INTERVAL '7' DAY

//

// Note also that naively `SELECT date` looks like a syntax error because the `date` type

// name is not followed by a string literal, but in fact in PostgreSQL it is a valid

// expression that should parse as the column name "date".

return_ok_if_some!(self.maybe_parse(|parser| {

match parser.parse_data_type()? {

DataType::Interval => parser.parse_interval(),

// PostgreSQL allows almost any identifier to be used as custom data type name,

// and we support that in `parse_data_type()`. But unlike Postgres we don't

// have a list of globally reserved keywords (since they vary across dialects),

// so given `NOT 'a' LIKE 'b'`, we'd accept `NOT` as a possible custom data type

// name, resulting in `NOT 'a'` being recognized as a `TypedString` instead of

// an unary negation `NOT ('a' LIKE 'b')`. To solve this, we don't accept the

// `type 'string'` syntax for the custom data types at all.

DataType::Custom(..) => parser_err!("dummy"),

data_type => Ok(Expr::TypedString {

data_type,

value: parser.parse_literal_string()?,

}),

}

}));

let next_token = self.next_token();

let expr = match next_token.token {

Token::Word(w) => match w.keyword {

Keyword::TRUE | Keyword::FALSE | Keyword::NULL => {

self.prev_token();

Ok(Expr::Value(self.parse_value()?))

}

Keyword::CURRENT_CATALOG

| Keyword::CURRENT_USER

| Keyword::SESSION_USER

| Keyword::USER

if dialect_of!(self is PostgreSqlDialect | GenericDialect) =>

{

Ok(Expr::Function(Function {

name: ObjectName(vec![w.to_ident()]),

args: vec![],

over: None,

distinct: false,

special: true,

order_by: vec![],

}))

}

Keyword::CURRENT_TIMESTAMP

| Keyword::CURRENT_TIME

| Keyword::CURRENT_DATE

| Keyword::LOCALTIME

| Keyword::LOCALTIMESTAMP => {

self.parse_time_functions(ObjectName(vec![w.to_ident()]))

}

Keyword::CASE => self.parse_case_expr(),

Keyword::CAST => self.parse_cast_expr(),

Keyword::TRY_CAST => self.parse_try_cast_expr(),

Keyword::SAFE_CAST => self.parse_safe_cast_expr(),

Keyword::EXISTS => self.parse_exists_expr(false),

Keyword::EXTRACT => self.parse_extract_expr(),

Keyword::CEIL => self.parse_ceil_floor_expr(true),

Keyword::FLOOR => self.parse_ceil_floor_expr(false),

Keyword::POSITION => self.parse_position_expr(),

Keyword::SUBSTRING => self.parse_substring_expr(),

Keyword::OVERLAY => self.parse_overlay_expr(),

Keyword::TRIM => self.parse_trim_expr(),

Keyword::INTERVAL => self.parse_interval(),

Keyword::LISTAGG => self.parse_listagg_expr(),

// Treat ARRAY[1,2,3] as an array [1,2,3], otherwise try as subquery or a function call

Keyword::ARRAY if self.peek_token() == Token::LBracket => {

self.expect_token(&Token::LBracket)?;

self.parse_array_expr(true)

}

Keyword::ARRAY

if self.peek_token() == Token::LParen

&& !dialect_of!(self is ClickHouseDialect) =>

{

self.expect_token(&Token::LParen)?;

self.parse_array_subquery()

}

Keyword::ARRAY_AGG => self.parse_array_agg_expr(),

Keyword::NOT => self.parse_not(),

Keyword::MATCH if dialect_of!(self is MySqlDialect | GenericDialect) => {

self.parse_match_against()

}

// Here `w` is a word, check if it's a part of a multi-part

// identifier, a function call, or a simple identifier:

_ => match self.peek_token().token {

Token::LParen | Token::Period => {

let mut id_parts: Vec<Ident> = vec![w.to_ident()];

while self.consume_token(&Token::Period) {

let next_token = self.next_token();

match next_token.token {

Token::Word(w) => id_parts.push(w.to_ident()),

_ => {

return self

.expected("an identifier or a '*' after '.'", next_token);

}

}

}

if self.consume_token(&Token::LParen) {

self.prev_token();

self.parse_function(ObjectName(id_parts))

} else {

Ok(Expr::CompoundIdentifier(id_parts))

}

}

// string introducer https://dev.mysql.com/doc/refman/8.0/en/charset-introducer.html

Token::SingleQuotedString(_)

| Token::DoubleQuotedString(_)

| Token::HexStringLiteral(_)

if w.value.starts_with('_') =>

{

Ok(Expr::IntroducedString {

introducer: w.value,

value: self.parse_introduced_string_value()?,

})

}

_ => Ok(Expr::Identifier(w.to_ident())),

},

}, // End of Token::Word

// array `[1, 2, 3]`

Token::LBracket => self.parse_array_expr(false),

tok @ Token::Minus | tok @ Token::Plus => {

let op = if tok == Token::Plus {

UnaryOperator::Plus

} else {

UnaryOperator::Minus

};

Ok(Expr::UnaryOp {

op,

expr: Box::new(self.parse_subexpr(Self::MUL_DIV_MOD_OP_PREC)?),

})

}

tok @ Token::DoubleExclamationMark

| tok @ Token::PGSquareRoot

| tok @ Token::PGCubeRoot

| tok @ Token::AtSign

| tok @ Token::Tilde

if dialect_of!(self is PostgreSqlDialect) =>

{

let op = match tok {

Token::DoubleExclamationMark => UnaryOperator::PGPrefixFactorial,

Token::PGSquareRoot => UnaryOperator::PGSquareRoot,

Token::PGCubeRoot => UnaryOperator::PGCubeRoot,

Token::AtSign => UnaryOperator::PGAbs,

Token::Tilde => UnaryOperator::PGBitwiseNot,

_ => unreachable!(),

};

Ok(Expr::UnaryOp {

op,

expr: Box::new(self.parse_subexpr(Self::PLUS_MINUS_PREC)?),

})

}

Token::EscapedStringLiteral(_) if dialect_of!(self is PostgreSqlDialect | GenericDialect) =>

{

self.prev_token();

Ok(Expr::Value(self.parse_value()?))

}

Token::Number(_, _)

| Token::SingleQuotedString(_)

| Token::DoubleQuotedString(_)

| Token::DollarQuotedString(_)

| Token::SingleQuotedByteStringLiteral(_)

| Token::DoubleQuotedByteStringLiteral(_)

| Token::RawStringLiteral(_)

| Token::NationalStringLiteral(_)

| Token::HexStringLiteral(_) => {

self.prev_token();

Ok(Expr::Value(self.parse_value()?))

}

Token::LParen => {

let expr =

if self.parse_keyword(Keyword::SELECT) || self.parse_keyword(Keyword::WITH) {

self.prev_token();

Expr::Subquery(Box::new(self.parse_query()?))

} else {

let exprs = self.parse_comma_separated(Parser::parse_expr)?;

match exprs.len() {

0 => unreachable!(), // parse_comma_separated ensures 1 or more

1 => Expr::Nested(Box::new(exprs.into_iter().next().unwrap())),

_ => Expr::Tuple(exprs),

}

};

self.expect_token(&Token::RParen)?;

if !self.consume_token(&Token::Period) {

Ok(expr)

} else {

let tok = self.next_token();

let key = match tok.token {

Token::Word(word) => word.to_ident(),

_ => return parser_err!(format!("Expected identifier, found: {tok}")),

};

Ok(Expr::CompositeAccess {

expr: Box::new(expr),

key,

})

}

}

Token::Placeholder(_) | Token::Colon | Token::AtSign => {

self.prev_token();

Ok(Expr::Value(self.parse_value()?))

}

_ => self.expected("an expression:", next_token),

}?;

if self.parse_keyword(Keyword::COLLATE) {

Ok(Expr::Collate {

expr: Box::new(expr),

collation: self.parse_object_name()?,

})

} else {

Ok(expr)

}

}

pub fn parse_function(&mut self, name: ObjectName) -> Result<Expr, ParserError> {

self.expect_token(&Token::LParen)?;

let distinct = self.parse_all_or_distinct()?.is_some();

let (args, order_by) = self.parse_optional_args_with_orderby()?;

let over = if self.parse_keyword(Keyword::OVER) {

if self.consume_token(&Token::LParen) {

let window_spec = self.parse_window_spec()?;

Some(WindowType::WindowSpec(window_spec))

} else {

Some(WindowType::NamedWindow(self.parse_identifier()?))

}

} else {

None

};

Ok(Expr::Function(Function {

name,

args,

over,

distinct,

special: false,

order_by,

}))

}

pub fn parse_time_functions(&mut self, name: ObjectName) -> Result<Expr, ParserError> {

let (args, order_by) = if self.consume_token(&Token::LParen) {

self.parse_optional_args_with_orderby()?

} else {

(vec![], vec![])

};

Ok(Expr::Function(Function {

name,

args,

over: None,

distinct: false,

special: false,

order_by,

}))

}

pub fn parse_window_frame_units(&mut self) -> Result<WindowFrameUnits, ParserError> {

let next_token = self.next_token();

match &next_token.token {

Token::Word(w) => match w.keyword {

Keyword::ROWS => Ok(WindowFrameUnits::Rows),

Keyword::RANGE => Ok(WindowFrameUnits::Range),

Keyword::GROUPS => Ok(WindowFrameUnits::Groups),

_ => self.expected("ROWS, RANGE, GROUPS", next_token)?,

},

_ => self.expected("ROWS, RANGE, GROUPS", next_token),

}

}

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

let units = self.parse_window_frame_units()?;

let (start_bound, end_bound) = if self.parse_keyword(Keyword::BETWEEN) {

let start_bound = self.parse_window_frame_bound()?;

self.expect_keyword(Keyword::AND)?;

let end_bound = Some(self.parse_window_frame_bound()?);

(start_bound, end_bound)

} else {

(self.parse_window_frame_bound()?, None)

};

Ok(WindowFrame {

units,

start_bound,

end_bound,

})

}

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

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

if self.parse_keywords(&[Keyword::CURRENT, Keyword::ROW]) {

Ok(WindowFrameBound::CurrentRow)

} else {

let rows = if self.parse_keyword(Keyword::UNBOUNDED) {

None

} else {

Some(Box::new(match self.peek_token().token {

Token::SingleQuotedString(_) => self.parse_interval()?,

_ => self.parse_expr()?,

}))

};

if self.parse_keyword(Keyword::PRECEDING) {

Ok(WindowFrameBound::Preceding(rows))

} else if self.parse_keyword(Keyword::FOLLOWING) {

Ok(WindowFrameBound::Following(rows))

} else {

self.expected("PRECEDING or FOLLOWING", self.peek_token())

}

}

}

/// parse a group by expr. a group by expr can be one of group sets, roll up, cube, or simple

/// expr.

fn parse_group_by_expr(&mut self) -> Result<Expr, ParserError> {

if self.dialect.supports_group_by_expr() {

if self.parse_keywords(&[Keyword::GROUPING, Keyword::SETS]) {

self.expect_token(&Token::LParen)?;

let result = self.parse_comma_separated(|p| p.parse_tuple(false, true))?;

self.expect_token(&Token::RParen)?;

Ok(Expr::GroupingSets(result))

} else if self.parse_keyword(Keyword::CUBE) {

self.expect_token(&Token::LParen)?;

let result = self.parse_comma_separated(|p| p.parse_tuple(true, true))?;

self.expect_token(&Token::RParen)?;

Ok(Expr::Cube(result))

} else if self.parse_keyword(Keyword::ROLLUP) {

self.expect_token(&Token::LParen)?;

let result = self.parse_comma_separated(|p| p.parse_tuple(true, true))?;

self.expect_token(&Token::RParen)?;

Ok(Expr::Rollup(result))

} else {

self.parse_expr()