($MSG:expr) => {

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

};

($($arg:tt)*) => {

Err(ParserError::ParserError(format!($($arg)*)))

};

fn from(e: TokenizerError) -> Self {

ParserError::TokenizerError(format!("{}", e))

}

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: String) -> 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().is_none() {

break;

} else 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() {

Some(t) => match t {

Token::Word(ref w) if w.keyword != "" => match w.keyword.as_ref() {

"SELECT" | "WITH" | "VALUES" => {

self.prev_token();

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

}

"CREATE" => Ok(self.parse_create()?),

"DROP" => Ok(self.parse_drop()?),

"DELETE" => Ok(self.parse_delete()?),

"INSERT" => Ok(self.parse_insert()?),

"UPDATE" => Ok(self.parse_update()?),

"ALTER" => Ok(self.parse_alter()?),

"COPY" => Ok(self.parse_copy()?),

"SET" => Ok(self.parse_set()?),

"SHOW" => Ok(self.parse_show()?),

"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.

"BEGIN" => Ok(self.parse_begin()?),

"COMMIT" => Ok(self.parse_commit()?),

"ROLLBACK" => Ok(self.parse_rollback()?),

"PEEK" => Ok(Statement::Peek {

immediate: self.parse_keyword("IMMEDIATE"),

name: self.parse_object_name()?,

}),

"TAIL" => Ok(Statement::Tail {

name: self.parse_object_name()?,

}),

"EXPLAIN" => Ok(self.parse_explain()?),

"FLUSH" => Ok(self.parse_flush()?),

_ => parser_err!(format!(

"Unexpected keyword {:?} at the beginning of a statement",

w.to_string()

)),

},

Token::LParen => {

self.prev_token();

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

}

unexpected => self.expected(

"a keyword at the beginning of a statement",

Some(unexpected),

),

},

None => self.expected("SQL statement", None),

}

}

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

}

/// Parse an expression prefix

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

let tok = self

.next_token()

.ok_or_else(|| ParserError::ParserError("Unexpected EOF".to_string()))?;

let expr = match tok {

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

"TRUE" | "FALSE" | "NULL" => {

self.prev_token();

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

}

"ARRAY" => {

self.prev_token();

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

}

"CASE" => self.parse_case_expr(),

"CAST" => self.parse_cast_expr(),

"DATE" => Ok(Expr::Value(self.parse_date()?)),

"EXISTS" => self.parse_exists_expr(),

"EXTRACT" => self.parse_extract_expr(),

"INTERVAL" => self.parse_literal_interval(),

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

op: UnaryOperator::Not,

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

}),

"TIME" => Ok(Expr::Value(Value::Time(self.parse_literal_string()?))),

"TIMESTAMP" => self.parse_timestamp(),

"TIMESTAMPTZ" => self.parse_timestamptz(),

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

Some(Token::LParen) | Some(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() {

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

Some(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::Parameter(s) => Ok(Expr::Parameter(match s.parse() {

Ok(n) => n,

Err(err) => return parser_err!("unable to parse parameter: {}", err),

})),

Token::LParen => {

let expr = if self.parse_keyword("SELECT") || self.parse_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", Some(unexpected)),

}?;

if self.parse_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 all = self.parse_keyword("ALL");

let distinct = self.parse_keyword("DISTINCT");

if all && distinct {

return parser_err!(format!(

"Cannot specify both ALL and DISTINCT in function: {}",

name.to_string(),

));

}

let args = self.parse_optional_args()?;

let over = if self.parse_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(vec!["PARTITION", "BY"]) {

// a list of possibly-qualified column names

self.parse_comma_separated(Parser::parse_expr)?

} else {

vec![]

};

let order_by = if self.parse_keywords(vec!["ORDER", "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(&mut self) -> Result<WindowFrame, ParserError> {

let units = match self.next_token() {

Some(Token::Word(w)) => w.keyword.parse::<WindowFrameUnits>()?,

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

};

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

let start_bound = self.parse_window_frame_bound()?;

self.expect_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(vec!["CURRENT", "ROW"]) {

Ok(WindowFrameBound::CurrentRow)

} else {

let rows = if self.parse_keyword("UNBOUNDED") {

None

} else {

Some(self.parse_literal_uint()?)

};

if self.parse_keyword("PRECEDING") {

Ok(WindowFrameBound::Preceding(rows))

} else if self.parse_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("WHEN") {

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

self.expect_keyword("WHEN")?;

}

let mut conditions = vec![];

let mut results = vec![];

loop {

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

self.expect_keyword("THEN")?;

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

if !self.parse_keyword("WHEN") {

break;

}

}

let else_result = if self.parse_keyword("ELSE") {

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

} else {

None

};

self.expect_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("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_extract_field()?;

self.expect_keyword("FROM")?;

let expr = self.parse_expr()?;

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

Ok(Expr::Extract {

field,

expr: Box::new(expr),

})

}

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

let tok = self.next_token();

if let Some(Token::Word(ref k)) = tok {

match k.keyword.as_ref() {

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

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

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

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

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

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

_ => self.expected("date/time field", tok)?,

}

} else {

self.expected("date/time field", tok)?

}

}

// Hacked version of parse_date_time_field to allow directly passing strs.

pub fn parse_date_time_field_given_str(

&mut self,

s: &str,

) -> Result<DateTimeField, ParserError> {

match s {

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

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

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

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

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

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

_ => parser_err!("Expected date/time field, found: {}", s),

}

}

/// Parse the kinds of things that can be fed to EXTRACT and DATE_TRUNC

pub fn parse_extract_field(&mut self) -> Result<ExtractField, ParserError> {

let tok = self.next_token();

let field: Result<ExtractField, _> = match tok {

Some(Token::Word(ref k)) => k.keyword.parse(),

Some(Token::SingleQuotedString(ref s)) => s.parse(),

_ => return self.expected("extract field token", tok),

};

match field {

Ok(f) => Ok(f),

Err(_) => self.expected("valid extract field", tok)?,

}

}

pub fn contains_date_time_str(&mut self, interval: &str) -> Result<bool, ParserError> {

let upper_case_interval = interval.to_uppercase();

let date_time_strs = ["YEAR", "MONTH", "DAY", "HOUR", "MINUTE", "SECOND"];

for dts in &date_time_strs {

if upper_case_interval.contains(dts) {

return Ok(true);

}

}

Ok(false)

}

fn parse_date(&mut self) -> Result<Value, ParserError> {

use std::convert::TryInto;

let value = self.parse_literal_string()?;

let pdt = Self::parse_interval_string(&value, &DateTimeField::Year)?;

match (pdt.year, pdt.month, pdt.day, pdt.hour) {

(Some(year), Some(month), Some(day), None) => {

let p_err = |e: std::num::TryFromIntError, field: &str| {

ParserError::ParserError(format!(

"{} in date '{}' is invalid: {}",

field, value, e

))

};

// type inference with try_into() fails so we need to mutate it negative

let mut year: i64 = year.try_into().map_err(|e| p_err(e, "Year"))?;

year *= pdt.positivity();

if month > 12 || month == 0 {

return parser_err!(

"Month in date '{}' must be a number between 1 and 12, got: {}",

value,

month

);

}

let month: u8 = month.try_into().expect("invalid month");

let day: u8 = day.try_into().map_err(|e| p_err(e, "Day"))?;

if day == 0 {

parser_err!("Day in date '{}' cannot be zero: {}", value, day)?;

}

Ok(Value::Date(value, ParsedDate { year, month, day }))

}

(Some(_), Some(_), Some(_), Some(hours)) => parser_err!(

"Hours cannot be supplied for DATE, got {} in '{}'",

hours,

value

),

(_, _, _, _) => Err(ParserError::ParserError(format!(

"year, day and month are all required, got: '{}'",

value

))),

}

}

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

if self.parse_keyword("WITH") {

self.expect_keywords(&["TIME", "ZONE"])?;

return Ok(Expr::Value(self.parse_timestamp_inner(true)?));

} else if self.parse_keyword("WITHOUT") {

self.expect_keywords(&["TIME", "ZONE"])?;

}

Ok(Expr::Value(self.parse_timestamp_inner(false)?))

}

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

Ok(Expr::Value(self.parse_timestamp_inner(true)?))

}

fn parse_timestamp_inner(&mut self, parse_timezone: bool) -> Result<Value, ParserError> {

use std::convert::TryInto;

let value = self.parse_literal_string()?;

let pdt = Self::parse_timestamp_string(&value, parse_timezone)?;

match (

pdt.year,

pdt.month,

pdt.day,

pdt.hour,

pdt.minute,

pdt.second,

pdt.nano,

pdt.timezone_offset_second,

) {

(

Some(year),

Some(month),

Some(day),

Some(hour),

Some(minute),

Some(second),

nano,

timezone_offset_second,

) => {

let p_err = |e: std::num::TryFromIntError, field: &str| {

ParserError::ParserError(format!(

"{} in date '{}' is invalid: {}",

field, value, e

))

};

// type inference with try_into() fails so we need to mutate it negative

let mut year: i64 = year.try_into().map_err(|e| p_err(e, "Year"))?;

year *= pdt.positivity();

if month > 12 || month == 0 {

return parser_err!(

"Month in date '{}' must be a number between 1 and 12, got: {}",

value,

month

);

}

let month: u8 = month.try_into().expect("invalid month");

if month == 0 {

parser_err!("Month in timestamp '{}' cannot be zero: {}", value, day)?;

}

let day: u8 = day.try_into().map_err(|e| p_err(e, "Day"))?;

if day == 0 {

parser_err!("Day in timestamp '{}' cannot be zero: {}", value, day)?;

}

let hour: u8 = hour.try_into().map_err(|e| p_err(e, "Hour"))?;

if hour > 23 {

parser_err!("Hour in timestamp '{}' cannot be > 23: {}", value, hour)?;

}

let minute: u8 = minute.try_into().map_err(|e| p_err(e, "Minute"))?;

if minute > 59 {

parser_err!("Minute in timestamp '{}' cannot be > 59: {}", value, minute)?;

}

let second: u8 = second.try_into().map_err(|e| p_err(e, "Minute"))?;

if second > 60 {

parser_err!("Second in timestamp '{}' cannot be > 60: {}", value, second)?;

}

if parse_timezone {

return Ok(Value::TimestampTz(

value,

ParsedTimestamp {

year,

month,

day,

hour,

minute,

second,

nano: nano.unwrap_or(0),

timezone_offset_second: timezone_offset_second.unwrap_or(0),

},

));

}

Ok(Value::Timestamp(

value,

ParsedTimestamp {

year,

month,

day,

hour,

minute,

second,

nano: nano.unwrap_or(0),

timezone_offset_second: 0,

},

))

}

_ => Err(ParserError::ParserError(format!(

"timestamp is missing fields, year through second are all required, got: '{}'",

value

))),

}

}

/// 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 raw_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 raw_value string.)

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

// the duration of the interval.

let mut raw_value = self.parse_literal_string()?;

let leading_field = if self.contains_date_time_str(&raw_value)? {

// Hack to allow INTERVAL types like:

// INTERVAL '-30 day'

let (new_raw_value, leading_field) = {

let split = raw_value.split(" ").collect::<Vec<&str>>();

if split.len() == 2 {

(

String::from(split[0]),

self.parse_date_time_field_given_str(&split[1].to_uppercase())?,

)

} else {

return parser_err!("Invalid INTERVAL: {:#?}", raw_value);

}

};

raw_value = new_raw_value;

leading_field

} else {

// 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, but we currently

// require at least the leading field, in accordance with the ANSI spec.

self.parse_date_time_field()?

};

let (leading_precision, last_field, fsec_precision) =

if leading_field == 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("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)

}

};

let value = Self::parse_interval_string(&raw_value, &leading_field)?;

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

value: raw_value,

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

debug!("parsing infix");

let tok = self.next_token().unwrap(); // safe as EOF's precedence is the lowest

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::Div => Some(BinaryOperator::Divide),

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

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

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

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

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

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

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

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

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

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

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

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

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

Token::Word(ref k) => match k.keyword.as_ref() {

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

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

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

"NOT" => {

if self.parse_keyword("LIKE") {

Some(BinaryOperator::NotLike)

} else {

None

}

}

_ => None,

},

_ => None,

};

if let Some(op) = regular_binary_operator {

let any = self.parse_keyword("ANY");

let some = !any && self.parse_keyword("SOME");

let all = !any && !some && self.parse_keyword("ALL");

if any || some || all {

use BinaryOperator::*;

match op {

Eq | NotEq | Gt | GtEq | Lt | LtEq => (),

_ => self.expected("comparison operator", Some(tok))?,

}

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

let query = self.parse_query()?;

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

if any || some {

Ok(Expr::Any {

left: Box::new(expr),

op,

right: Box::new(query),

some,