// 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 crate::ast::*;

use crate::dialect::*;

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

use crate::tokenizer::*;

#[derive(Debug, Clone, PartialEq)]

pub enum ParserError {

TokenizerError(String),

ParserError(String),

}

// 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);

}

}};

}

#[derive(PartialEq)]

pub enum IsOptional {

Optional,

Mandatory,

}

use IsOptional::*;

pub enum IsLateral {

Lateral,

NotLateral,

}

use IsLateral::*;

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,

}

)

}

}

#[cfg(feature = "std")]

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

pub struct Parser<'a> {

tokens: Vec<Token>,

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

index: usize,

dialect: &'a dyn Dialect,

}

impl<'a> Parser<'a> {

/// Parse the specified tokens

pub fn new(tokens: Vec<Token>, dialect: &'a dyn Dialect) -> Self {

Parser {

tokens,

index: 0,

dialect,

}

}

/// Parse a SQL statement and produce an Abstract Syntax Tree (AST)

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

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

let tokens = tokenizer.tokenize()?;

let mut parser = Parser::new(tokens, dialect);

let mut stmts = Vec::new();

let mut expecting_statement_delimiter = false;

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

loop {

// ignore empty statements (between successive statement delimiters)

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

expecting_statement_delimiter = false;

}

if parser.peek_token() == Token::EOF {

break;

}

if expecting_statement_delimiter {

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

}

let statement = parser.parse_statement()?;

stmts.push(statement);

expecting_statement_delimiter = true;

}

Ok(stmts)

}

/// 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> {

match self.next_token() {

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

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::DROP => Ok(self.parse_drop()?),

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

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

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

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

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

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

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

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()?),

Keyword::REPLACE if dialect_of!(self is SQLiteDialect ) => {

self.prev_token();

Ok(self.parse_insert()?)

}

Keyword::COMMENT if dialect_of!(self is PostgreSqlDialect) => {

Ok(self.parse_comment()?)

}

_ => self.expected("an SQL statement", Token::Word(w)),

},

Token::LParen => {

self.prev_token();

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

}

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

}

}

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> {

self.expect_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,

})

}

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;

match self.next_token() {

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

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

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

match self.next_token() {

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

Token::Mul => {

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

}

unexpected => {

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

}

}

}

}

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> {

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_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> {

// 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_literal_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 expr = match self.next_token() {

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

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

self.prev_token();

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

}

Keyword::CURRENT_TIMESTAMP | Keyword::CURRENT_TIME | Keyword::CURRENT_DATE => {

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::EXISTS => self.parse_exists_expr(),

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

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

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

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

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

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

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

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

self.parse_array_expr(true)

}

Keyword::NOT => Ok(Expr::UnaryOp {

op: UnaryOperator::Not,

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

}),

// 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::LParen | Token::Period => {

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

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

match self.next_token() {

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

unexpected => {

return self

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

}

}

}

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

self.prev_token();

self.parse_function(ObjectName(id_parts))

} else {

Ok(Expr::CompoundIdentifier(id_parts))

}

}

_ => 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::PLUS_MINUS_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::Number(_, _)

| Token::SingleQuotedString(_)

| 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)?;

Ok(expr)

}

Token::Placeholder(_) => {

self.prev_token();

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

}

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

}?;

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()?;

let args = self.parse_optional_args()?;

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

// TBD: support window names (`OVER mywin`) in place of inline specification

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

let partition_by = if self.parse_keywords(&[Keyword::PARTITION, Keyword::BY]) {

// a list of possibly-qualified column names

self.parse_comma_separated(Parser::parse_expr)?

} else {

vec![]

};

let order_by = if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) {

self.parse_comma_separated(Parser::parse_order_by_expr)?

} else {

vec![]

};

let window_frame = if !self.consume_token(&Token::RParen) {

let window_frame = self.parse_window_frame()?;

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

Some(window_frame)

} else {

None

};

Some(WindowSpec {

partition_by,

order_by,

window_frame,

})

} else {

None

};

Ok(Expr::Function(Function {

name,

args,

over,

distinct,

}))

}

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

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

self.parse_optional_args()?

} else {

vec![]

};

Ok(Expr::Function(Function {

name,

args,

over: None,

distinct: false,

}))

}

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

match self.next_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", Token::Word(w))?,

},

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

}

}

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(self.parse_literal_uint()?)

};

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 dialect_of!(self is PostgreSqlDialect) {

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()

}

} else {

// TODO parse rollup for other dialects

self.parse_expr()

}

}

/// parse a tuple with `(` and `)`.

/// If `lift_singleton` is true, then a singleton tuple is lifted to a tuple of length 1, otherwise it will fail.

/// If `allow_empty` is true, then an empty tuple is allowed.

fn parse_tuple(

&mut self,

lift_singleton: bool,

allow_empty: bool,

) -> Result<Vec<Expr>, ParserError> {

if lift_singleton {

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

let result = if allow_empty && self.consume_token(&Token::RParen) {

vec![]

} else {

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

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

result

};

Ok(result)

} else {

Ok(vec![self.parse_expr()?])

}

} else {

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

let result = if allow_empty && self.consume_token(&Token::RParen) {

vec![]

} else {

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

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

result

};

Ok(result)

}

}

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

let mut operand = None;

if !self.parse_keyword(Keyword::WHEN) {

operand = Some(Box::new(self.parse_expr()?));

self.expect_keyword(Keyword::WHEN)?;

}

let mut conditions = vec![];

let mut results = vec![];

loop {

conditions.push(self.parse_expr()?);

self.expect_keyword(Keyword::THEN)?;

results.push(self.parse_expr()?);

if !self.parse_keyword(Keyword::WHEN) {

break;

}

}

let else_result = if self.parse_keyword(Keyword::ELSE) {

Some(Box::new(self.parse_expr()?))

} else {

None

};

self.expect_keyword(Keyword::END)?;

Ok(Expr::Case {

operand,

conditions,

results,

else_result,

})

}

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

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

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

let expr = self.parse_expr()?;

self.expect_keyword(Keyword::AS)?;

let data_type = self.parse_data_type()?;

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

Ok(Expr::Cast {

expr: Box::new(expr),

data_type,

})

}

/// Parse a SQL TRY_CAST function e.g. `TRY_CAST(expr AS FLOAT)`

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

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

let expr = self.parse_expr()?;

self.expect_keyword(Keyword::AS)?;

let data_type = self.parse_data_type()?;

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

Ok(Expr::TryCast {

expr: Box::new(expr),

data_type,

})

}

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

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

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

let exists_node = Expr::Exists(Box::new(self.parse_query()?));

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

Ok(exists_node)

}

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

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

let field = self.parse_date_time_field()?;

self.expect_keyword(Keyword::FROM)?;

let expr = self.parse_expr()?;

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

Ok(Expr::Extract {

field,

expr: Box::new(expr),

})

}

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

// PARSE SUBSTRING (EXPR [FROM 1] [FOR 3])

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

let expr = self.parse_expr()?;

let mut from_expr = None;

if self.parse_keyword(Keyword::FROM) || self.consume_token(&Token::Comma) {

from_expr = Some(self.parse_expr()?);

}

let mut to_expr = None;

if self.parse_keyword(Keyword::FOR) || self.consume_token(&Token::Comma) {

to_expr = Some(self.parse_expr()?);

}

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

Ok(Expr::Substring {

expr: Box::new(expr),

substring_from: from_expr.map(Box::new),

substring_for: to_expr.map(Box::new),

})

}

/// TRIM (WHERE 'text' FROM 'text')\

/// TRIM ('text')

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

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

let mut where_expr = None;

if let Token::Word(word) = self.peek_token() {

if [Keyword::BOTH, Keyword::LEADING, Keyword::TRAILING]

.iter()

.any(|d| word.keyword == *d)

{

let trim_where = self.parse_trim_where()?;

let sub_expr = self.parse_expr()?;

self.expect_keyword(Keyword::FROM)?;

where_expr = Some((trim_where, Box::new(sub_expr)));

}

}

let expr = self.parse_expr()?;

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

Ok(Expr::Trim {

expr: Box::new(expr),

trim_where: where_expr,

})

}

pub fn parse_trim_where(&mut self) -> Result<TrimWhereField, ParserError> {

match self.next_token() {

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

Keyword::BOTH => Ok(TrimWhereField::Both),

Keyword::LEADING => Ok(TrimWhereField::Leading),

Keyword::TRAILING => Ok(TrimWhereField::Trailing),

_ => self.expected("trim_where field", Token::Word(w))?,

},

unexpected => self.expected("trim_where field", unexpected),

}

}

/// Parses an array expression `[ex1, ex2, ..]`

/// if `named` is `true`, came from an expression like `ARRAY[ex1, ex2]`

pub fn parse_array_expr(&mut self, named: bool) -> Result<Expr, ParserError> {

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

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

Ok(Expr::Array(Array { elem: exprs, named }))

}

/// Parse a SQL LISTAGG expression, e.g. `LISTAGG(...) WITHIN GROUP (ORDER BY ...)`.

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

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

let distinct = self.parse_all_or_distinct()?;

let expr = Box::new(self.parse_expr()?);

// While ANSI SQL would would require the separator, Redshift makes this optional. Here we

// choose to make the separator optional as this provides the more general implementation.

let separator = if self.consume_token(&Token::Comma) {

Some(Box::new(self.parse_expr()?))

} else {

None

};

let on_overflow = if self.parse_keywords(&[Keyword::ON, Keyword::OVERFLOW]) {

if self.parse_keyword(Keyword::ERROR) {

Some(ListAggOnOverflow::Error)

} else {

self.expect_keyword(Keyword::TRUNCATE)?;

let filler = match self.peek_token() {

Token::Word(w)

if w.keyword == Keyword::WITH || w.keyword == Keyword::WITHOUT =>

{

None

}

Token::SingleQuotedString(_)

| Token::NationalStringLiteral(_)

| Token::HexStringLiteral(_) => Some(Box::new(self.parse_expr()?)),

unexpected => {

self.expected("either filler, WITH, or WITHOUT in LISTAGG", unexpected)?

}

};

let with_count = self.parse_keyword(Keyword::WITH);

if !with_count && !self.parse_keyword(Keyword::WITHOUT) {

self.expected("either WITH or WITHOUT in LISTAGG", self.peek_token())?;

}

self.expect_keyword(Keyword::COUNT)?;

Some(ListAggOnOverflow::Truncate { filler, with_count })

}

} else {

None

};

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

// Once again ANSI SQL requires WITHIN GROUP, but Redshift does not. Again we choose the

// more general implementation.

let within_group = if self.parse_keywords(&[Keyword::WITHIN, Keyword::GROUP]) {

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

self.expect_keywords(&[Keyword::ORDER, Keyword::BY])?;

let order_by_expr = self.parse_comma_separated(Parser::parse_order_by_expr)?;

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

order_by_expr

} else {

vec![]

};

Ok(Expr::ListAgg(ListAgg {

distinct,

expr,

separator,

on_overflow,

within_group,

}))

}

// This function parses date/time fields for both the EXTRACT function-like

// operator and interval qualifiers. EXTRACT supports a wider set of

// date/time fields than interval qualifiers, so this function may need to

// be split in two.

pub fn parse_date_time_field(&mut self) -> Result<DateTimeField, ParserError> {

match self.next_token() {

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

Keyword::YEAR => Ok(DateTimeField::Year),

Keyword::MONTH => Ok(DateTimeField::Month),

Keyword::WEEK => Ok(DateTimeField::Week),

Keyword::DAY => Ok(DateTimeField::Day),

Keyword::HOUR => Ok(DateTimeField::Hour),

Keyword::MINUTE => Ok(DateTimeField::Minute),

Keyword::SECOND => Ok(DateTimeField::Second),

Keyword::CENTURY => Ok(DateTimeField::Century),

Keyword::DECADE => Ok(DateTimeField::Decade),

Keyword::DOY => Ok(DateTimeField::Doy),

Keyword::DOW => Ok(DateTimeField::Dow),

Keyword::EPOCH => Ok(DateTimeField::Epoch),

Keyword::ISODOW => Ok(DateTimeField::Isodow),

Keyword::ISOYEAR => Ok(DateTimeField::Isoyear),

Keyword::JULIAN => Ok(DateTimeField::Julian),

Keyword::MICROSECONDS => Ok(DateTimeField::Microseconds),

Keyword::MILLENIUM => Ok(DateTimeField::Millenium),

Keyword::MILLISECONDS => Ok(DateTimeField::Milliseconds),

Keyword::QUARTER => Ok(DateTimeField::Quarter),

Keyword::TIMEZONE => Ok(DateTimeField::Timezone),

Keyword::TIMEZONE_HOUR => Ok(DateTimeField::TimezoneHour),

Keyword::TIMEZONE_MINUTE => Ok(DateTimeField::TimezoneMinute),

_ => self.expected("date/time field", Token::Word(w))?,

},

unexpected => self.expected("date/time field", unexpected),

}

}

/// 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:1.1' HOUR (5) TO SECOND (5)`

/// 5. `INTERVAL '1.1' SECOND (2, 2)`

/// 6. `INTERVAL '1:1' HOUR (5) TO MINUTE (5)`

///

/// Note that we do not currently attempt to parse the quoted value.

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

// The SQL standard allows an optional sign before the value string, but

// it is not clear if any implementations support that syntax, so we

// don't currently try to parse it. (The sign can instead be included

// inside the value string.)

// The first token in an interval is a string literal which specifies

// the duration of the interval.

let value = self.parse_literal_string()?;

// Following the string literal is a qualifier which indicates the units

// of the duration specified in the string literal.

//

// Note that PostgreSQL allows omitting the qualifier, so we provide

// this more general implemenation.

let leading_field = match self.peek_token() {

Token::Word(kw)

if [

Keyword::YEAR,

Keyword::MONTH,

Keyword::WEEK,

Keyword::DAY,

Keyword::HOUR,

Keyword::MINUTE,

Keyword::SECOND,

Keyword::CENTURY,

Keyword::DECADE,

Keyword::DOW,

Keyword::DOY,

Keyword::EPOCH,

Keyword::ISODOW,

Keyword::ISOYEAR,

Keyword::JULIAN,

Keyword::MICROSECONDS,

Keyword::MILLENIUM,

Keyword::MILLISECONDS,

Keyword::QUARTER,

Keyword::TIMEZONE,

Keyword::TIMEZONE_HOUR,

Keyword::TIMEZONE_MINUTE,

]

.iter()

.any(|d| kw.keyword == *d) =>

{