($MSG:expr) => {

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

};

($e:expr) => {{

if let Some(v) = $e {

return Ok(v);

}

}};

fn from(e: TokenizerError) -> Self {

ParserError::TokenizerError(format!(

"{} at Line: {}, Column {}",

e.message, e.line, e.col

))

}

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

write!(

f,

"sql parser error: {}",

match self {

ParserError::TokenizerError(s) => s,

ParserError::ParserError(s) => s,

}

)

}

tokens: Vec<Token>,

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

index: usize,

/// Parse the specified tokens

pub fn new(tokens: Vec<Token>) -> Self {

Parser { tokens, index: 0 }

}

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

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::SELECT | Keyword::WITH | Keyword::VALUES => {

self.prev_token();

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

}

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

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

}

}

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

Keyword::EXTRACT => self.parse_extract_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::Mult => {

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::Mult => 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)?),

})

}

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

})

}

/// 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::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::Mult => Some(BinaryOperator::Multiply),

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

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::Word(w) => match w.keyword {

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

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

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

Keyword::NOT => {

if self.parse_keyword(Keyword::LIKE) {

Some(BinaryOperator::NotLike)

} else {

None

}

}

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

self.expected("NULL or NOT NULL 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

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

}

} else if Token::DoubleColon == tok {

self.parse_pg_cast(expr)

} else {

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

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

}

}

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

}

};

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

Ok(in_op)

}

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

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

// Stop parsing subexpressions for <low> and <high> on tokens with

// precedence lower than that of `BETWEEN`, such as `AND`, `IS`, etc.

let low = self.parse_subexpr(Self::BETWEEN_PREC)?;

self.expect_keyword(Keyword::AND)?;

let high = self.parse_subexpr(Self::BETWEEN_PREC)?;

Ok(Expr::Between {

expr: Box::new(expr),

negated,

low: Box::new(low),

high: Box::new(high),

})

}

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

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

Ok(Expr::Cast {

expr: Box::new(expr),

data_type: self.parse_data_type()?,

})

}

const UNARY_NOT_PREC: u8 = 15;

const BETWEEN_PREC: u8 = 20;

const PLUS_MINUS_PREC: u8 = 30;

/// Get the precedence of the next token

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

let token = self.peek_token();

debug!("get_next_precedence() {:?}", token);

match token {

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

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

Token::Word(w) if w.keyword == Keyword::NOT => match self.peek_nth_token(1) {

// The precedence of NOT varies depending on keyword that

// follows it. If it is followed by IN, BETWEEN, or LIKE,

// it takes on the precedence of those tokens. Otherwise it

// is not an infix operator, and therefore has zero

// precedence.

Token::Word(w) if w.keyword == Keyword::IN => Ok(Self::BETWEEN_PREC),

Token::Word(w) if w.keyword == Keyword::BETWEEN => Ok(Self::BETWEEN_PREC),

Token::Word(w) if w.keyword == Keyword::LIKE => Ok(Self::BETWEEN_PREC),

_ => Ok(0),

},

Token::Word(w) if w.keyword == Keyword::IS => Ok(17),

Token::Word(w) if w.keyword == Keyword::IN => Ok(Self::BETWEEN_PREC),

Token::Word(w) if w.keyword == Keyword::BETWEEN => Ok(Self::BETWEEN_PREC),

Token::Word(w) if w.keyword == Keyword::LIKE => Ok(Self::BETWEEN_PREC),

Token::Eq | Token::Lt | Token::LtEq | Token::Neq | Token::Gt | Token::GtEq => Ok(20),

Token::Pipe => Ok(21),

Token::Caret => Ok(22),

Token::Ampersand => Ok(23),

Token::Plus | Token::Minus => Ok(Self::PLUS_MINUS_PREC),

Token::Mult | Token::Div | Token::Mod | Token::StringConcat => Ok(40),

Token::DoubleColon => Ok(50),

_ => Ok(0),

}

}

/// Return the first non-whitespace token that has not yet been processed

/// (or None if reached end-of-file)

pub fn peek_token(&self) -> Token {

self.peek_nth_token(0)

}

/// Return nth non-whitespace token that has not yet been processed

pub fn peek_nth_token(&self, mut n: usize) -> Token {