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

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::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::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::REPLACE if dialect_of!(self is SQLiteDialect ) => {

self.prev_token();

Ok(self.parse_insert()?)

}

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

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

}

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

// PosgreSQL 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::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(),

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

let mut ends_with_wildcard = false;

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

match self.next_token() {

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

Token::Mul => {

ends_with_wildcard = true;

break;

}

unexpected => {

return self

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

}

}

}

if ends_with_wildcard {

Ok(Expr::QualifiedWildcard(id_parts))

} else 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

Token::Mul => Ok(Expr::Wildcard),

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 {

Expr::Nested(Box::new(self.parse_expr()?))

};

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

Ok(expr)

}

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

}

}

}

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;

let mut to_expr = None;

if self.parse_keyword(Keyword::FROM) {

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

}

if self.parse_keyword(Keyword::FOR) {

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

}

}

/// 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::DAY => Ok(DateTimeField::Day),

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

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

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

_ => 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::DAY,

Keyword::HOUR,

Keyword::MINUTE,

Keyword::SECOND,

]

.iter()

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

{

Some(self.parse_date_time_field()?)

}

_ => None,

};

let (leading_precision, last_field, fsec_precision) =

if leading_field == Some(DateTimeField::Second) {

// SQL mandates special syntax for `SECOND TO SECOND` literals.

// Instead of

// `SECOND [(<leading precision>)] TO SECOND[(<fractional seconds precision>)]`

// one must use the special format:

// `SECOND [( <leading precision> [ , <fractional seconds precision>] )]`

let last_field = None;

let (leading_precision, fsec_precision) = self.parse_optional_precision_scale()?;

(leading_precision, last_field, fsec_precision)

} else {

let leading_precision = self.parse_optional_precision()?;

if self.parse_keyword(Keyword::TO) {

let last_field = Some(self.parse_date_time_field()?);

let fsec_precision = if last_field == Some(DateTimeField::Second) {

self.parse_optional_precision()?

} else {

None

};

(leading_precision, last_field, fsec_precision)

} else {

(leading_precision, None, None)

}

};

Ok(Expr::Value(Value::Interval {

value,

leading_field,

leading_precision,

last_field,

fractional_seconds_precision: fsec_precision,

}))

}

/// Parse an operator following an expression

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

let tok = self.next_token();

let regular_binary_operator = match &tok {

Token::Spaceship => Some(BinaryOperator::Spaceship),

Token::DoubleEq => Some(BinaryOperator::Eq),

Token::Eq => Some(BinaryOperator::Eq),

Token::Neq => Some(BinaryOperator::NotEq),

Token::Gt => Some(BinaryOperator::Gt),

Token::GtEq => Some(BinaryOperator::GtEq),

Token::Lt => Some(BinaryOperator::Lt),

Token::LtEq => Some(BinaryOperator::LtEq),

Token::Plus => Some(BinaryOperator::Plus),

Token::Minus => Some(BinaryOperator::Minus),

Token::Mul => Some(BinaryOperator::Multiply),

Token::Mod => Some(BinaryOperator::Modulo),

Token::StringConcat => Some(BinaryOperator::StringConcat),

Token::Pipe => Some(BinaryOperator::BitwiseOr),

Token::Caret => Some(BinaryOperator::BitwiseXor),

Token::Ampersand => Some(BinaryOperator::BitwiseAnd),

Token::Div => Some(BinaryOperator::Divide),

Token::ShiftLeft if dialect_of!(self is PostgreSqlDialect) => {

Some(BinaryOperator::PGBitwiseShiftLeft)

}

Token::ShiftRight if dialect_of!(self is PostgreSqlDialect) => {

Some(BinaryOperator::PGBitwiseShiftRight)

}

Token::Sharp if dialect_of!(self is PostgreSqlDialect) => {

Some(BinaryOperator::PGBitwiseXor)

}

Token::Tilde => Some(BinaryOperator::PGRegexMatch),

Token::TildeAsterisk => Some(BinaryOperator::PGRegexIMatch),

Token::ExclamationMarkTilde => Some(BinaryOperator::PGRegexNotMatch),

Token::ExclamationMarkTildeAsterisk => Some(BinaryOperator::PGRegexNotIMatch),

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

Keyword::AND => Some(BinaryOperator::And),

Keyword::OR => Some(BinaryOperator::Or),

Keyword::LIKE => Some(BinaryOperator::Like),

Keyword::ILIKE => Some(BinaryOperator::ILike),

Keyword::NOT => {

if self.parse_keyword(Keyword::LIKE) {

Some(BinaryOperator::NotLike)

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

Some(BinaryOperator::NotILike)

} else {

None

}

}

Keyword::XOR => Some(BinaryOperator::Xor),

_ => None,

},

_ => None,

};

if let Some(op) = regular_binary_operator {

Ok(Expr::BinaryOp {

left: Box::new(expr),

op,

right: Box::new(self.parse_subexpr(precedence)?),

})

} else if let Token::Word(w) = &tok {

match w.keyword {

Keyword::IS => {

if self.parse_keyword(Keyword::NULL) {

Ok(Expr::IsNull(Box::new(expr)))

} else if self.parse_keywords(&[Keyword::NOT, Keyword::NULL]) {

Ok(Expr::IsNotNull(Box::new(expr)))

} else if self.parse_keywords(&[Keyword::DISTINCT, Keyword::FROM]) {

let expr2 = self.parse_expr()?;

Ok(Expr::IsDistinctFrom(Box::new(expr), Box::new(expr2)))

} else if self.parse_keywords(&[Keyword::NOT, Keyword::DISTINCT, Keyword::FROM])

{

let expr2 = self.parse_expr()?;

Ok(Expr::IsNotDistinctFrom(Box::new(expr), Box::new(expr2)))

} else {

self.expected(

"[NOT] NULL or [NOT] DISTINCT FROM after IS",

self.peek_token(),

)

}

}

Keyword::NOT | Keyword::IN | Keyword::BETWEEN => {

self.prev_token();

let negated = self.parse_keyword(Keyword::NOT);

if self.parse_keyword(Keyword::IN) {

self.parse_in(expr, negated)

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

self.parse_between(expr, negated)

} else {

self.expected("IN or BETWEEN after NOT", self.peek_token())

}

}

// Can only happen if `get_next_precedence` got out of sync with this function

_ => parser_err!(format!("No infix parser for token {:?}", tok)),

}

} else if Token::DoubleColon == tok {

self.parse_pg_cast(expr)

} else if Token::ExclamationMark == tok {

// PostgreSQL factorial operation

Ok(Expr::UnaryOp {

op: UnaryOperator::PGPostfixFactorial,

expr: Box::new(expr),

})

} else if Token::LBracket == tok {

self.parse_map_access(expr)

} else {

// Can only happen if `get_next_precedence` got out of sync with this function

parser_err!(format!("No infix parser for token {:?}", tok))

}

}

pub fn parse_map_access(&mut self, expr: Expr) -> Result<Expr, ParserError> {

let key = self.parse_map_key()?;

let tok = self.consume_token(&Token::RBracket);

debug!("Tok: {}", tok);

let mut key_parts: Vec<Value> = vec![key];

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

let key = self.parse_map_key()?;

let tok = self.consume_token(&Token::RBracket);

debug!("Tok: {}", tok);

key_parts.push(key);

}

match expr {

e @ Expr::Identifier(_) | e @ Expr::CompoundIdentifier(_) => Ok(Expr::MapAccess {

column: Box::new(e),

keys: key_parts,

}),

_ => Ok(expr),

}

}

/// Parses the parens following the `[ NOT ] IN` operator

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

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

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

self.prev_token();

Expr::InSubquery {

expr: Box::new(expr),

subquery: Box::new(self.parse_query()?),

negated,

}

} else {

Expr::InList {

expr: Box::new(expr),

list: self.parse_comma_separated(Parser::parse_expr)?,

negated,

}

};