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

#![warn(clippy::all)]

//! Test SQL syntax, which all sqlparser dialects must parse in the same way.

//!

//! Note that it does not mean all SQL here is valid in all the dialects, only

//! that 1) it's either standard or widely supported and 2) it can be parsed by

//! sqlparser regardless of the chosen dialect (i.e. it doesn't conflict with

//! dialect-specific parsing rules).

extern crate core;

#[macro_use]

mod test_utils;

use matches::assert_matches;

use sqlparser::ast::Expr::BinaryOp;

use sqlparser::ast::*;

use sqlparser::dialect::{GenericDialect, PostgreSqlDialect, SQLiteDialect};

use sqlparser::keywords::ALL_KEYWORDS;

use sqlparser::parser::{Parser, ParserError};

use sqlparser::tokenizer::QueryOffset;

use test_utils::{

all_dialects, expr_from_projection, join, number, only, table, table_alias, TestedDialects,

};

#[test]

fn parse_insert_values() {

let row = vec![

Expr::Value(number("1")),

Expr::Value(number("2")),

Expr::Value(number("3")),

];

let rows1 = vec![row.clone()];

let rows2 = vec![row.clone(), row];

let sql = "INSERT INTO customer VALUES (1, 2, 3)";

check_one(sql, "customer", &[], &rows1, "");

let sql = "INSERT INTO customer VALUES (1, 2, 3), (1, 2, 3)";

check_one(sql, "customer", &[], &rows2, "");

let sql = "INSERT INTO public.customer VALUES (1, 2, 3)";

check_one(sql, "public.customer", &[], &rows1, "");

let sql = "INSERT INTO db.public.customer VALUES (1, 2, 3)";

check_one(sql, "db.public.customer", &[], &rows1, "");

let sql = "INSERT INTO public.customer (id, name, active) VALUES (1, 2, 3)";

check_one(

sql,

"public.customer",

&["id".to_string(), "name".to_string(), "active".to_string()],

&rows1,

"",

);

fn check_one(

sql: &str,

expected_table_name: &str,

expected_columns: &[String],

expected_rows: &[Vec<Expr>],

expected_format: &str,

) {

match verified_stmt(sql) {

Statement::Insert {

table_name,

columns,

source,

format,

..

} => {

assert_eq!(table_name.to_string(), expected_table_name);

assert_eq!(columns.len(), expected_columns.len());

for (index, column) in columns.iter().enumerate() {

assert_eq!(column.value, expected_columns[index]);

}

match &source {

Some(source) => match &source.body {

SetExpr::Values(Values(values)) => {

assert_eq!(values.as_slice(), expected_rows)

}

_ => unreachable!(),

},

None => {

assert_eq!(format.unwrap(), expected_format)

}

}

}

_ => unreachable!(),

}

}

verified_stmt("INSERT INTO customer WITH foo AS (SELECT 1) SELECT * FROM foo UNION VALUES (1)");

}

#[test]

fn parse_stream_values_insert() {

struct TestCase {

sql: String,

expected_table_name: String,

expected_columns: Vec<String>,

expected_values: String,

expected_format: String,

}

let tests = vec![

TestCase {

sql: "INSERT INTO t values (1,2,3);".to_string(),

expected_table_name: "t".to_string(),

expected_columns: vec![],

expected_values: " (1,2,3)".to_string(),

expected_format: "".to_string(),

},

TestCase {

sql: "INSERT INTO t values (1,2,3) ;".to_string(),

expected_table_name: "t".to_string(),

expected_columns: vec![],

expected_values: " (1,2,3) ".to_string(),

expected_format: "".to_string(),

},

TestCase {

sql: "INSERT INTO t values ;".to_string(),

expected_table_name: "t".to_string(),

expected_columns: vec![],

expected_values: " ".to_string(),

expected_format: "".to_string(),

},

TestCase {

sql: "INSERT INTO t FORMAT CSV".to_string(),

expected_table_name: "t".to_string(),

expected_columns: vec![],

expected_values: "".to_string(),

expected_format: "CSV".to_string(),

},

TestCase {

sql: "INSERT INTO t FORMAT NDJSON".to_string(),

expected_table_name: "t".to_string(),

expected_columns: vec![],

expected_values: "".to_string(),

expected_format: "NDJSON".to_string(),

},

TestCase {

sql: "insert into a(a) format CSV \n100\n200\n300;".to_string(),

expected_table_name: "a".to_string(),

expected_columns: vec!["a".to_string()],

expected_values: " \n100\n200\n300".to_string(),

expected_format: "CSV".to_string(),

},

TestCase {

sql: "insert into t values(now(), now(), today(), today());".to_string(),

expected_table_name: "t".to_string(),

expected_columns: vec![],

expected_values: "(now(), now(), today(), today())".to_string(),

expected_format: "".to_string(),

},

TestCase {

sql: "INSERT INTO t(c1,c2) FORMAT TSV 1\t3\n3\t4".to_string(),

expected_table_name: "t".to_string(),

expected_columns: vec![String::from("c1"), String::from("c2")],

expected_values: " 1\t3\n3\t4".to_string(),

expected_format: "TSV".to_string(),

},

];

for test in tests.iter() {

let sql = test.sql.as_str();

let expected_table_name = test.expected_table_name.as_str();

let expected_columns = &test.expected_columns;

let expected_format = test.expected_format.as_str();

let expected_values = test.expected_values.as_str();

all_dialects().run_parser_method(sql, |parser| {

parser.next_token();

match parser.parse_stream_format_insert().unwrap() {

Statement::Insert {

table_name,

columns,

source,

format,

..

} => {

assert_eq!(table_name.to_string(), expected_table_name);

assert_eq!(columns.len(), expected_columns.len());

for (index, column) in columns.iter().enumerate() {

assert_eq!(column.value, expected_columns[index]);

}

match &source {

Some(source) => match &source.body {

SetExpr::Streams(streams) => {

let values = match (&streams.start, &streams.end) {

(QueryOffset::Normal(start), QueryOffset::Normal(end)) => {

&sql[*start as usize..*end as usize]

}

(QueryOffset::Normal(start), QueryOffset::EOF) => {

&sql[*start as usize..]

}

(QueryOffset::EOF, QueryOffset::EOF) => "",

_ => unreachable!(),

};

assert_eq!(values, expected_values)

}

_ => unreachable!(),

},

None => {

assert_eq!(format.unwrap(), expected_format);

}

}

}

_ => unreachable!(),

}

});

}

}

#[test]

fn parse_insert_stream_values_invalid() {

struct TestCase {

sql: String,

expected_err: ParserError,

}

let tests: Vec<TestCase> = vec![

TestCase {

sql: "INSERT into t z 1,2,3) on".to_string(),

expected_err: ParserError::ParserError(

"Expected SELECT, VALUES, FORMAT or a subquery in the query body, found: z"

.to_string(),

),

},

TestCase {

sql: "INSERT into t t 1,2,3) on;".to_string(),

expected_err: ParserError::ParserError(

"Expected SELECT, VALUES, FORMAT or a subquery in the query body, found: t"

.to_string(),

),

},

];

for test in tests.iter() {

let sql = test.sql.as_str();

let expected_err = &test.expected_err;

all_dialects().run_parser_method(sql, |parser| {

parser.next_token();

let result = parser.parse_stream_format_insert();

assert_eq!(&result.unwrap_err(), expected_err);

});

}

}

#[test]

fn parse_insert_invalid() {

let sql = "INSERT public.customer (id, name, active) VALUES (1, 2, 3)";

let res = parse_sql_statements(sql);

assert_eq!(

ParserError::ParserError("Expected one of INTO or OVERWRITE, found: public".to_string()),

res.unwrap_err()

);

}

#[test]

fn parse_insert_sqlite() {

let dialect = SQLiteDialect {};

let check = |sql: &str, expected_action: Option<SqliteOnConflict>| match Parser::parse_sql(

&dialect, sql,

)

.unwrap()

.pop()

.unwrap()

{

Statement::Insert { or, .. } => assert_eq!(or, expected_action),

_ => panic!("{}", sql),

};

let sql = "INSERT INTO test_table(id) VALUES(1)";

check(sql, None);

let sql = "REPLACE INTO test_table(id) VALUES(1)";

check(sql, Some(SqliteOnConflict::Replace));

let sql = "INSERT OR REPLACE INTO test_table(id) VALUES(1)";

check(sql, Some(SqliteOnConflict::Replace));

let sql = "INSERT OR ROLLBACK INTO test_table(id) VALUES(1)";

check(sql, Some(SqliteOnConflict::Rollback));

let sql = "INSERT OR ABORT INTO test_table(id) VALUES(1)";

check(sql, Some(SqliteOnConflict::Abort));

let sql = "INSERT OR FAIL INTO test_table(id) VALUES(1)";

check(sql, Some(SqliteOnConflict::Fail));

let sql = "INSERT OR IGNORE INTO test_table(id) VALUES(1)";

check(sql, Some(SqliteOnConflict::Ignore));

}

#[test]

fn parse_update() {

let sql = "UPDATE t SET a = 1, b = 2, c = 3 WHERE d";

match verified_stmt(sql) {

Statement::Update {

table,

assignments,

selection,

..

} => {

assert_eq!(table.to_string(), "t".to_string());

assert_eq!(

assignments,

vec![

Assignment {

id: vec!["a".into()],

value: Expr::Value(number("1")),

},

Assignment {

id: vec!["b".into()],

value: Expr::Value(number("2")),

},

Assignment {

id: vec!["c".into()],

value: Expr::Value(number("3")),

},

]

);

assert_eq!(selection.unwrap(), Expr::Identifier("d".into()));

}

_ => unreachable!(),

}

verified_stmt("UPDATE t SET a = 1, a = 2, a = 3");

let sql = "UPDATE t WHERE 1";

let res = parse_sql_statements(sql);

assert_eq!(

ParserError::ParserError("Expected SET, found: WHERE".to_string()),

res.unwrap_err()

);

let sql = "UPDATE t SET a = 1 extrabadstuff";

let res = parse_sql_statements(sql);

assert_eq!(

ParserError::ParserError("Expected end of statement, found: extrabadstuff".to_string()),

res.unwrap_err()

);

}

#[test]

fn parse_update_with_table_alias() {

let sql = "UPDATE users AS u SET u.username = 'new_user' WHERE u.username = 'old_user'";

match verified_stmt(sql) {

Statement::Update {

table,

assignments,

selection,

} => {

assert_eq!(

TableWithJoins {

relation: TableFactor::Table {

name: ObjectName(vec![Ident::new("users")]),

alias: Some(TableAlias {

name: Ident::new("u"),

columns: vec![]

}),

args: vec![],

with_hints: vec![],

instant: None,

},

joins: vec![]

},

table

);

assert_eq!(

vec![Assignment {

id: vec![Ident::new("u"), Ident::new("username")],

value: Expr::Value(Value::SingleQuotedString("new_user".to_string()))

}],

assignments

);

assert_eq!(

Some(Expr::BinaryOp {

left: Box::new(Expr::CompoundIdentifier(vec![

Ident::new("u"),

Ident::new("username")

])),

op: BinaryOperator::Eq,

right: Box::new(Expr::Value(Value::SingleQuotedString(

"old_user".to_string()

)))

}),

selection

);

}

_ => unreachable!(),

}

}

#[test]

fn parse_invalid_table_name() {

let ast = all_dialects()

.run_parser_method("db.public..customer", |parser| parser.parse_object_name());

assert!(ast.is_err());

}

#[test]

fn parse_no_table_name() {

let ast = all_dialects().run_parser_method("", |parser| parser.parse_object_name());

assert!(ast.is_err());

}

#[test]

fn parse_delete_statement() {

let sql = "DELETE FROM \"table\"";

match verified_stmt(sql) {

Statement::Delete { table_name, .. } => {

assert_eq!(

ObjectName(vec![Ident::with_quote('"', "table")]),

table_name

);

}

_ => unreachable!(),

}

}

#[test]

fn parse_where_delete_statement() {

use self::BinaryOperator::*;

let sql = "DELETE FROM foo WHERE name = 5";

match verified_stmt(sql) {

Statement::Delete {

table_name,

selection,

..

} => {

assert_eq!(ObjectName(vec![Ident::new("foo")]), table_name);

assert_eq!(

Expr::BinaryOp {

left: Box::new(Expr::Identifier(Ident::new("name"))),

op: Eq,

right: Box::new(Expr::Value(number("5"))),

},

selection.unwrap(),

);

}

_ => unreachable!(),

}

}

#[test]

fn parse_top_level() {

verified_stmt("SELECT 1");

verified_stmt("(SELECT 1)");

verified_stmt("((SELECT 1))");

verified_stmt("VALUES (1)");

}

#[test]

fn parse_simple_select() {

let sql = "SELECT id, fname, lname FROM customer WHERE id = 1 LIMIT 5";

let select = verified_only_select(sql);

assert!(!select.distinct);

assert_eq!(3, select.projection.len());

let select = verified_query(sql);

assert_eq!(Some(Expr::Value(number("5"))), select.limit);

let sql = "SELECT customer.`id`, `customer`.lname, `fname`, `customer`.`id`, customer.*, `customer`.* FROM db.customer";

let select = verified_only_select(sql);

assert_eq!(6, select.projection.len());

let sql = "SELECT `table`.`col`";

let select = verified_only_select(sql);

assert_eq!(1, select.projection.len());

}

#[test]

fn parse_limit_is_not_an_alias() {

// In dialects supporting LIMIT it shouldn't be parsed as a table alias

let ast = verified_query("SELECT id FROM customer LIMIT 1");

assert_eq!(Some(Expr::Value(number("1"))), ast.limit);

let ast = verified_query("SELECT 1 LIMIT 5");

assert_eq!(Some(Expr::Value(number("5"))), ast.limit);

}

#[test]

fn parse_select_distinct() {

let sql = "SELECT DISTINCT name FROM customer";

let select = verified_only_select(sql);

assert!(select.distinct);

assert_eq!(

&SelectItem::UnnamedExpr(Expr::Identifier(Ident::new("name"))),

only(&select.projection)

);

}

#[test]

fn parse_select_all() {

one_statement_parses_to("SELECT ALL name FROM customer", "SELECT name FROM customer");

}

#[test]

fn parse_select_all_distinct() {

let result = parse_sql_statements("SELECT ALL DISTINCT name FROM customer");

assert_eq!(

ParserError::ParserError("Cannot specify both ALL and DISTINCT".to_string()),

result.unwrap_err(),

);

}

#[test]

fn parse_select_at() {

let select = verified_only_select("SELECT * FROM t at (snapshot => 'the_id')");

let from: &TableWithJoins = &select.from[0];

match &from.relation {

TableFactor::Table { instant, .. } => {

if let Some(Instant::SnapshotID(s)) = instant {

assert_eq!("the_id", s.as_str());

} else {

panic!("expecting snapshot id")

}

}

_ => panic!(" expecting TableFactor::Table"),

}

}

#[test]

fn parse_select_wildcard() {

let sql = "SELECT * FROM foo";

let select = verified_only_select(sql);

assert_eq!(&SelectItem::Wildcard, only(&select.projection));

let sql = "SELECT `foo`.* FROM foo";

let select = verified_only_select(sql);

assert_eq!(

&SelectItem::QualifiedWildcard(ObjectName(vec![Ident::with_quote('`', "foo")])),

only(&select.projection)

);

let sql = "SELECT myschema.mytable.* FROM myschema.mytable";

let select = verified_only_select(sql);

assert_eq!(

&SelectItem::QualifiedWildcard(ObjectName(vec![

Ident::new("myschema"),

Ident::new("mytable"),

])),

only(&select.projection)

);

let sql = "SELECT * + * FROM foo;";

let result = parse_sql_statements(sql);

assert_eq!(

ParserError::ParserError("Expected end of statement, found: +".to_string()),

result.unwrap_err(),

);

}

#[test]

fn parse_select_with_format() {

let ast = verified_query("SELECT foo FROM bar LIMIT 3 FORMAT json");

assert_eq!(ast.format, Some("json".to_string()));

let ast = verified_query("SELECT foo FROM bar FORMAT CSV");

assert_eq!(ast.format, Some("CSV".to_string()));

let ast = verified_query("SELECT foo FROM bar FORMAT PARQUET");

assert_eq!(ast.format, Some("PARQUET".to_string()));

}

#[test]

fn parse_count_wildcard() {

verified_only_select("SELECT COUNT(*) FROM Order WHERE id = 10");

verified_only_select(

"SELECT COUNT(Employee.*) FROM Order JOIN Employee ON Order.employee = Employee.id",

);

}

#[test]

fn parse_column_aliases() {

let sql = "SELECT a.col + 1 AS newname FROM foo AS a";

let select = verified_only_select(sql);

if let SelectItem::ExprWithAlias {

expr: Expr::BinaryOp {

ref op, ref right, ..

},

ref alias,

} = only(&select.projection)

{

assert_eq!(&BinaryOperator::Plus, op);

assert_eq!(&Expr::Value(number("1")), right.as_ref());

assert_eq!(&Ident::new("newname"), alias);

} else {

panic!("Expected ExprWithAlias")

}

// alias without AS is parsed correctly:

one_statement_parses_to("SELECT a.col + 1 newname FROM foo AS a", sql);

}

#[test]

fn parse_column_aliases_with_back_quoted() {

let sql = "SELECT a.col + 1 AS `newname` FROM foo AS a";

let select = verified_only_select(sql);

let mut ident = Ident::new("newname");

ident.quote_style = Some('`');

if let SelectItem::ExprWithAlias {

expr: Expr::BinaryOp {

ref op, ref right, ..

},

ref alias,

} = only(&select.projection)

{

assert_eq!(&BinaryOperator::Plus, op);

assert_eq!(&Expr::Value(number("1")), right.as_ref());

assert_eq!(&ident, alias);

} else {

panic!("Expected ExprWithAlias")

}

// alias without AS is parsed correctly:

one_statement_parses_to("SELECT a.col + 1 `newname` FROM foo AS a", sql);

let sql = "SELECT `a`.`col` + 1 AS `newname` FROM `foo` AS a";

one_statement_parses_to("SELECT `a`.`col` + 1 `newname` FROM `foo` AS a", sql);

}

#[test]

fn test_eof_after_as() {

let res = parse_sql_statements("SELECT foo AS");

assert_eq!(

ParserError::ParserError("Expected an identifier after AS, found: EOF".to_string()),

res.unwrap_err()

);

let res = parse_sql_statements("SELECT `foo` AS");

assert_eq!(

ParserError::ParserError("Expected an identifier after AS, found: EOF".to_string()),

res.unwrap_err()

);

let res = parse_sql_statements("SELECT 1 FROM foo AS");

assert_eq!(

ParserError::ParserError("Expected an identifier after AS, found: EOF".to_string()),

res.unwrap_err()

);

}

#[test]

fn test_no_infix_error() {

let res = Parser::parse_sql(&GenericDialect {}, "ASSERT-URA<<");

assert_eq!(

ParserError::ParserError("No infix parser for token ShiftLeft".to_string()),

res.unwrap_err()

);

}

#[test]

fn parse_select_count_wildcard() {

let sql = "SELECT COUNT(*) FROM customer";

let select = verified_only_select(sql);

assert_eq!(

&Expr::Function(Function {

name: ObjectName(vec![Ident::new("COUNT")]),

params: vec![],

args: vec![FunctionArg::Unnamed(FunctionArgExpr::Wildcard)],

over: None,

distinct: false,

}),

expr_from_projection(only(&select.projection))

);

}

#[test]

fn parse_select_count_distinct() {

let sql = "SELECT COUNT(DISTINCT + x) FROM customer";

let select = verified_only_select(sql);

assert_eq!(

&Expr::Function(Function {

name: ObjectName(vec![Ident::new("COUNT")]),

params: vec![],

args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::UnaryOp {

op: UnaryOperator::Plus,

expr: Box::new(Expr::Identifier(Ident::new("x"))),

}))],

over: None,

distinct: true,

}),

expr_from_projection(only(&select.projection))

);

one_statement_parses_to(

"SELECT COUNT(ALL + x) FROM customer",

"SELECT COUNT(+ x) FROM customer",

);

let sql = "SELECT COUNT(ALL DISTINCT + x) FROM customer";

let res = parse_sql_statements(sql);

assert_eq!(

ParserError::ParserError("Cannot specify both ALL and DISTINCT".to_string()),

res.unwrap_err()

);

}

#[test]

fn parse_function_with_params() {

let sql = "SELECT funnel(3600)(x, y) FROM customer";

let select = verified_only_select(sql);

assert_eq!(

&Expr::Function(Function {

name: ObjectName(vec![Ident::new("funnel")]),

params: vec![Value::Number("3600".parse().unwrap(), false)],

args: vec![

FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Identifier(Ident::new("x")))),

FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Identifier(Ident::new("y"))))

],

over: None,

distinct: false,

}),

expr_from_projection(only(&select.projection))

);

}

#[test]

fn parse_not() {

let sql = "SELECT id FROM customer WHERE NOT salary = ''";

let _ast = verified_only_select(sql);

//TODO: add assertions

}

#[test]

fn parse_invalid_infix_not() {

let res = parse_sql_statements("SELECT c FROM t WHERE c NOT (");

assert_eq!(

ParserError::ParserError("Expected end of statement, found: NOT".to_string()),

res.unwrap_err(),

);

}

#[test]

fn parse_collate() {

let sql = "SELECT name COLLATE \"de_DE\" FROM customer";

assert_matches!(

only(&all_dialects().verified_only_select(sql).projection),

SelectItem::UnnamedExpr(Expr::Collate { .. })

);

}

#[test]

fn parse_select_string_predicate() {

let sql = "SELECT id, fname, lname FROM customer \

WHERE salary <> 'Not Provided' AND salary <> ''";

let _ast = verified_only_select(sql);

//TODO: add assertions

}

#[test]

fn parse_projection_nested_type() {

let sql = "SELECT customer.address.state FROM foo";

let _ast = verified_only_select(sql);

//TODO: add assertions

}

#[test]

fn parse_null_in_select() {

let sql = "SELECT NULL";

let select = verified_only_select(sql);

assert_eq!(

&Expr::Value(Value::Null),

expr_from_projection(only(&select.projection)),

);

}

#[test]

fn parse_select_with_date_column_name() {

let sql = "SELECT date";

let select = verified_only_select(sql);

assert_eq!(

&Expr::Identifier(Ident {

value: "date".into(),

quote_style: None

}),

expr_from_projection(only(&select.projection)),

);

}

#[test]

fn parse_escaped_single_quote_string_predicate() {

use self::BinaryOperator::*;

let sql = "SELECT id, fname, lname FROM customer \

WHERE salary <> 'Jim''s salary'";

let ast = verified_only_select(sql);

assert_eq!(

Some(Expr::BinaryOp {

left: Box::new(Expr::Identifier(Ident::new("salary"))),

op: NotEq,

right: Box::new(Expr::Value(Value::SingleQuotedString(

"Jim's salary".to_string()

)))

}),

ast.selection,

);

}

#[test]

fn parse_select_where_map_access() {

let sql = "SELECT * FROM test WHERE id = 'a' AND labels:email = 'abc@test.com'";

let ast = verified_only_select(sql);

assert_eq!(

Some(Expr::BinaryOp {

left: Box::new(Expr::BinaryOp {

left: Box::new(Expr::Identifier(Ident::new("id"))),

op: BinaryOperator::Eq,

right: Box::new(Expr::Value(Value::SingleQuotedString("a".to_string())))

}),

op: BinaryOperator::And,

right: Box::new(Expr::BinaryOp {

left: Box::new(Expr::MapAccess {

column: Box::new(Expr::Identifier(Ident::new("labels"))),

keys: vec![Value::ColonString("email".into())],

}),

op: BinaryOperator::Eq,

right: Box::new(Expr::Value(Value::SingleQuotedString(

"abc@test.com".to_string()

)))

})

}),

ast.selection,

);

let sql = "SELECT * FROM test WHERE id = 'a' OR 'abc@test.com' = labels:email";

let ast = verified_only_select(sql);

assert_eq!(

Some(Expr::BinaryOp {

left: Box::new(Expr::BinaryOp {

left: Box::new(Expr::Identifier(Ident::new("id"))),

op: BinaryOperator::Eq,

right: Box::new(Expr::Value(Value::SingleQuotedString("a".to_string())))

}),

op: BinaryOperator::Or,

right: Box::new(Expr::BinaryOp {

left: Box::new(Expr::Value(Value::SingleQuotedString(

"abc@test.com".to_string()

))),

op: BinaryOperator::Eq,

right: Box::new(Expr::MapAccess {

column: Box::new(Expr::Identifier(Ident::new("labels"))),

keys: vec![Value::ColonString("email".into())],

})

})

}),

ast.selection,

);

}

#[test]

fn parse_number() {

let expr = verified_expr("1.0");

#[cfg(feature = "bigdecimal")]

assert_eq!(

expr,

Expr::Value(Value::Number(bigdecimal::BigDecimal::from(1), false))

);

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

assert_eq!(expr, Expr::Value(Value::Number("1.0".into(), false)));

}

#[test]

fn parse_compound_expr_1() {

use self::BinaryOperator::*;

use self::Expr::*;

let sql = "a + b * c";

assert_eq!(

BinaryOp {

left: Box::new(Identifier(Ident::new("a"))),

op: Plus,

right: Box::new(BinaryOp {

left: Box::new(Identifier(Ident::new("b"))),

op: Multiply,

right: Box::new(Identifier(Ident::new("c")))

})

},

verified_expr(sql)

);

}

#[test]

fn parse_compound_expr_2() {

use self::BinaryOperator::*;

use self::Expr::*;

let sql = "a * b + c";

assert_eq!(

BinaryOp {

left: Box::new(BinaryOp {

left: Box::new(Identifier(Ident::new("a"))),

op: Multiply,

right: Box::new(Identifier(Ident::new("b")))

}),

op: Plus,

right: Box::new(Identifier(Ident::new("c")))

},

verified_expr(sql)

);

}

#[test]

fn parse_compound_expr_3() {

use self::BinaryOperator::*;

use self::Expr::*;

let sql = "a + b DIV c";

assert_eq!(

BinaryOp {

left: Box::new(Identifier(Ident::new("a"))),

op: Plus,

right: Box::new(BinaryOp {

left: Box::new(Identifier(Ident::new("b"))),

op: Div,

right: Box::new(Identifier(Ident::new("c")))

})

},

verified_expr(sql)

);

}

#[test]

fn parse_unary_math() {

use self::Expr::*;

let sql = "- a + - b";

assert_eq!(

BinaryOp {

left: Box::new(UnaryOp {

op: UnaryOperator::Minus,

expr: Box::new(Identifier(Ident::new("a"))),

}),

op: BinaryOperator::Plus,

right: Box::new(UnaryOp {

op: UnaryOperator::Minus,

expr: Box::new(Identifier(Ident::new("b"))),

}),

},

verified_expr(sql)

);

}

#[test]

fn parse_is_null() {

use self::Expr::*;

let sql = "a IS NULL";

assert_eq!(

IsNull(Box::new(Identifier(Ident::new("a")))),

verified_expr(sql)

);

}

#[test]

fn parse_is_not_null() {

use self::Expr::*;

let sql = "a IS NOT NULL";

assert_eq!(

IsNotNull(Box::new(Identifier(Ident::new("a")))),

verified_expr(sql)

);

}

#[test]

fn parse_is_distinct_from() {

use self::Expr::*;

let sql = "a IS DISTINCT FROM b";

assert_eq!(

IsDistinctFrom(

Box::new(Identifier(Ident::new("a"))),

Box::new(Identifier(Ident::new("b")))

),

verified_expr(sql)

);

}

#[test]

fn parse_is_not_distinct_from() {

use self::Expr::*;

let sql = "a IS NOT DISTINCT FROM b";

assert_eq!(

IsNotDistinctFrom(

Box::new(Identifier(Ident::new("a"))),

Box::new(Identifier(Ident::new("b")))

),

verified_expr(sql)

);