#![warn(clippy::all)]
#[macro_use]
mod test_utils;
use test_utils::{all_dialects, expr_from_projection, join, number, only, table, table_alias};
use matches::assert_matches;
use models_parser::ast::*;
use models_parser::dialect::{keywords::ALL_KEYWORDS, GenericDialect, SQLiteDialect};
use models_parser::parser::{Parser, ParserError};
#[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>],
) {
match verified_stmt(sql) {
Statement::Insert(Insert {
table_name,
columns,
source,
..
}) => {
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, &Ident::new(expected_columns[index].clone()));
}
match &source.body {
SetExpr::Values(Values(values)) => assert_eq!(values.as_slice(), expected_rows),
_ => unreachable!(),
}
}
_ => unreachable!(),
}
}
verified_stmt("INSERT INTO customer WITH foo AS (SELECT 1) SELECT * FROM foo UNION VALUES (1)");
}
#[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(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(Update {
table_name,
assignments,
selection,
..
}) => {
assert_eq!(table_name.to_string(), "t".to_string());
assert_eq!(
assignments,
vec![
Assignment {
id: "a".into(),
value: Expr::Value(number("1")),
},
Assignment {
id: "b".into(),
value: Expr::Value(number("2")),
},
Assignment {
id: "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_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(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(Delete {
table_name,
selection,
..
}) => {
assert_eq!(ObjectName(vec![Ident::new("foo")]), table_name);
assert_eq!(
Expr::BinaryOp(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);
}
#[test]
fn parse_limit_is_not_an_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_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::new("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)
);
}
#[test]
fn parse_count_wildcard() {
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(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")
}
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 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")]),
args: vec![FunctionArg::Unnamed(Expr::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")]),
args: vec![FunctionArg::Unnamed(Expr::UnaryOp(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_not() {
let sql = "SELECT id FROM customer WHERE NOT salary = ''";
let _ast = verified_only_select(sql);
}
#[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);
}
#[test]
fn parse_projection_nested_type() {
let sql = "SELECT customer.address.state FROM foo";
let _ast = verified_only_select(sql);
}
#[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(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_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::Identifier;
let sql = "a + b * c";
assert_eq!(
Expr::BinaryOp(BinaryOp {
left: Box::new(Identifier(Ident::new("a"))),
op: Plus,
right: Box::new(Expr::BinaryOp(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::*;
let sql = "a * b + c";
assert_eq!(
Expr::BinaryOp(BinaryOp {
left: Box::new(Expr::BinaryOp(BinaryOp {
left: Box::new(Expr::Identifier(Ident::new("a"))),
op: Multiply,
right: Box::new(Expr::Identifier(Ident::new("b")))
})),
op: Plus,
right: Box::new(Expr::Identifier(Ident::new("c")))
}),
verified_expr(sql)
);
}
#[test]
fn parse_unary_math() {
let sql = "- a + - b";
assert_eq!(
Expr::BinaryOp(BinaryOp {
left: Box::new(Expr::UnaryOp(UnaryOp {
op: UnaryOperator::Minus,
expr: Box::new(Expr::Identifier(Ident::new("a"))),
})),
op: BinaryOperator::Plus,
right: Box::new(Expr::UnaryOp(UnaryOp {
op: UnaryOperator::Minus,
expr: Box::new(Expr::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_not_precedence() {
let sql = "NOT true OR true";
assert_matches!(
verified_expr(sql),
Expr::BinaryOp(BinaryOp {
op: BinaryOperator::Or,
..
})
);
let sql = "NOT a IS NULL";
assert_matches!(
verified_expr(sql),
Expr::UnaryOp(UnaryOp {
op: UnaryOperator::Not,
..
})
);
let sql = "NOT 1 NOT BETWEEN 1 AND 2";
assert_eq!(
verified_expr(sql),
Expr::UnaryOp(UnaryOp {
op: UnaryOperator::Not,
expr: Box::new(Expr::Between(Between {
expr: Box::new(Expr::Value(number("1"))),
low: Box::new(Expr::Value(number("1"))),
high: Box::new(Expr::Value(number("2"))),
negated: true,
})),
}),
);
let sql = "NOT 'a' NOT LIKE 'b'";
assert_eq!(
verified_expr(sql),
Expr::UnaryOp(UnaryOp {
op: UnaryOperator::Not,
expr: Box::new(Expr::BinaryOp(BinaryOp {
left: Box::new(Expr::Value(Value::SingleQuotedString("a".into()))),
op: BinaryOperator::NotLike,
right: Box::new(Expr::Value(Value::SingleQuotedString("b".into()))),
})),
}),
);
let sql = "NOT a NOT IN ('a')";
assert_eq!(
verified_expr(sql),
Expr::UnaryOp(UnaryOp {
op: UnaryOperator::Not,
expr: Box::new(Expr::InList(InList {
expr: Box::new(Expr::Identifier("a".into())),
list: vec![Expr::Value(Value::SingleQuotedString("a".into()))],
negated: true,
})),
}),
);
}
#[test]
fn parse_like() {
fn chk(negated: bool) {
let sql = &format!(
"SELECT * FROM customers WHERE name {}LIKE '%a'",
if negated { "NOT " } else { "" }
);
let select = verified_only_select(sql);
assert_eq!(
Expr::BinaryOp(BinaryOp {
left: Box::new(Expr::Identifier(Ident::new("name"))),
op: if negated {
BinaryOperator::NotLike
} else {
BinaryOperator::Like
},
right: Box::new(Expr::Value(Value::SingleQuotedString("%a".to_string()))),
}),
select.selection.unwrap()
);
let sql = &format!(
"SELECT * FROM customers WHERE name {}LIKE '%a' IS NULL",
if negated { "NOT " } else { "" }
);
let select = verified_only_select(sql);
assert_eq!(
Expr::IsNull(Box::new(Expr::BinaryOp(BinaryOp {
left: Box::new(Expr::Identifier(Ident::new("name"))),
op: if negated {
BinaryOperator::NotLike
} else {
BinaryOperator::Like
},
right: Box::new(Expr::Value(Value::SingleQuotedString("%a".to_string()))),
}))),
select.selection.unwrap()
);
}
chk(false);
chk(true);
}
#[test]
fn parse_ilike() {
fn chk(negated: bool) {
let sql = &format!(
"SELECT * FROM customers WHERE name {}ILIKE '%a'",
if negated { "NOT " } else { "" }
);
let select = verified_only_select(sql);
assert_eq!(
Expr::BinaryOp(BinaryOp {
left: Box::new(Expr::Identifier(Ident::new("name"))),
op: if negated {
BinaryOperator::NotILike
} else {
BinaryOperator::ILike
},
right: Box::new(Expr::Value(Value::SingleQuotedString("%a".to_string()))),
}),
select.selection.unwrap()
);
let sql = &format!(
"SELECT * FROM customers WHERE name {}ILIKE '%a' IS NULL",
if negated { "NOT " } else { "" }
);
let select = verified_only_select(sql);
assert_eq!(
Expr::IsNull(Box::new(Expr::BinaryOp(BinaryOp {
left: Box::new(Expr::Identifier(Ident::new("name"))),
op: if negated {
BinaryOperator::NotILike
} else {
BinaryOperator::ILike
},
right: Box::new(Expr::Value(Value::SingleQuotedString("%a".to_string()))),
}))),
select.selection.unwrap()
);
}
chk(false);
chk(true);
}
#[test]
fn parse_in_list() {
fn chk(negated: bool) {
let sql = &format!(
"SELECT * FROM customers WHERE segment {}IN ('HIGH', 'MED')",
if negated { "NOT " } else { "" }
);
let select = verified_only_select(sql);
assert_eq!(
Expr::InList(InList {
expr: Box::new(Expr::Identifier(Ident::new("segment"))),
list: vec![
Expr::Value(Value::SingleQuotedString("HIGH".to_string())),
Expr::Value(Value::SingleQuotedString("MED".to_string())),
],
negated,
}),
select.selection.unwrap()
);
}
chk(false);
chk(true);
}
#[test]
fn parse_in_subquery() {
let sql = "SELECT * FROM customers WHERE segment IN (SELECT segm FROM bar)";
let select = verified_only_select(sql);
assert_eq!(
Expr::InSubquery(InSubquery {
expr: Box::new(Expr::Identifier(Ident::new("segment"))),
subquery: Box::new(verified_query("SELECT segm FROM bar")),
negated: false,
}),
select.selection.unwrap()
);
}
#[test]
fn parse_string_agg() {
let sql = "SELECT a || b";
let select = verified_only_select(sql);
assert_eq!(
SelectItem::UnnamedExpr(Expr::BinaryOp(BinaryOp {
left: Box::new(Expr::Identifier(Ident::new("a"))),
op: BinaryOperator::StringConcat,
right: Box::new(Expr::Identifier(Ident::new("b"))),
})),
select.projection[0]
);
}
#[test]
fn parse_bitwise_ops() {
let bitwise_ops = &[
("^", BinaryOperator::BitwiseXor),
("|", BinaryOperator::BitwiseOr),
("&", BinaryOperator::BitwiseAnd),
];
for (str_op, op) in bitwise_ops {
let select = verified_only_select(&format!("SELECT a {} b", &str_op));
assert_eq!(
SelectItem::UnnamedExpr(Expr::BinaryOp(BinaryOp {
left: Box::new(Expr::Identifier(Ident::new("a"))),
op: op.clone(),
right: Box::new(Expr::Identifier(Ident::new("b"))),
})),
select.projection[0]
);
}
}
#[test]
fn parse_between() {
fn chk(negated: bool) {
let sql = &format!(
"SELECT * FROM customers WHERE age {}BETWEEN 25 AND 32",
if negated { "NOT " } else { "" }
);
let select = verified_only_select(sql);
assert_eq!(
Expr::Between(Between {
expr: Box::new(Expr::Identifier(Ident::new("age"))),
low: Box::new(Expr::Value(number("25"))),
high: Box::new(Expr::Value(number("32"))),
negated,
}),
select.selection.unwrap()
);
}
chk(false);
chk(true);
}
#[test]
fn parse_between_with_expr() {
use self::BinaryOperator::*;
let sql = "SELECT * FROM t WHERE 1 BETWEEN 1 + 2 AND 3 + 4 IS NULL";
let select = verified_only_select(sql);
assert_eq!(
Expr::IsNull(Box::new(Expr::Between(Between {
expr: Box::new(Expr::Value(number("1"))),
low: Box::new(Expr::BinaryOp(BinaryOp {
left: Box::new(Expr::Value(number("1"))),
op: Plus,
right: Box::new(Expr::Value(number("2"))),
})),
high: Box::new(Expr::BinaryOp(BinaryOp {
left: Box::new(Expr::Value(number("3"))),
op: Plus,
right: Box::new(Expr::Value(number("4"))),
})),
negated: false,
}))),
select.selection.unwrap()
);
let sql = "SELECT * FROM t WHERE 1 = 1 AND 1 + x BETWEEN 1 AND 2";
let select = verified_only_select(sql);
assert_eq!(
Expr::BinaryOp(BinaryOp {
left: Box::new(Expr::BinaryOp(BinaryOp {
left: Box::new(Expr::Value(number("1"))),
op: BinaryOperator::Eq,
right: Box::new(Expr::Value(number("1"))),
})),
op: BinaryOperator::And,
right: Box::new(Expr::Between(Between {
expr: Box::new(Expr::BinaryOp(BinaryOp {
left: Box::new(Expr::Value(number("1"))),
op: BinaryOperator::Plus,
right: Box::new(Expr::Identifier(Ident::new("x"))),
})),
low: Box::new(Expr::Value(number("1"))),
high: Box::new(Expr::Value(number("2"))),
negated: false,
})),
}),
select.selection.unwrap(),
)
}
#[test]
fn parse_select_order_by() {
fn chk(sql: &str) {
let select = verified_query(sql);
assert_eq!(
vec![
OrderByExpr {
expr: Expr::Identifier(Ident::new("lname")),
asc: Some(true),
nulls_first: None,
},
OrderByExpr {
expr: Expr::Identifier(Ident::new("fname")),
asc: Some(false),
nulls_first: None,
},
OrderByExpr {
expr: Expr::Identifier(Ident::new("id")),
asc: None,
nulls_first: None,
},
],
select.order_by
);
}
chk("SELECT id, fname, lname FROM customer WHERE id < 5 ORDER BY lname ASC, fname DESC, id");
chk("SELECT id, fname, lname FROM customer ORDER BY lname ASC, fname DESC, id");
chk("SELECT 1 AS lname, 2 AS fname, 3 AS id, 4 ORDER BY lname ASC, fname DESC, id");
}
#[test]
fn parse_select_order_by_limit() {
let sql = "SELECT id, fname, lname FROM customer WHERE id < 5 \
ORDER BY lname ASC, fname DESC LIMIT 2";
let select = verified_query(sql);
assert_eq!(
vec![
OrderByExpr {
expr: Expr::Identifier(Ident::new("lname")),
asc: Some(true),
nulls_first: None,
},
OrderByExpr {
expr: Expr::Identifier(Ident::new("fname")),
asc: Some(false),
nulls_first: None,
},
],
select.order_by
);
assert_eq!(Some(Expr::Value(number("2"))), select.limit);
}
#[test]
fn parse_select_order_by_nulls_order() {
let sql = "SELECT id, fname, lname FROM customer WHERE id < 5 \
ORDER BY lname ASC NULLS FIRST, fname DESC NULLS LAST LIMIT 2";
let select = verified_query(sql);
assert_eq!(
vec![
OrderByExpr {
expr: Expr::Identifier(Ident::new("lname")),
asc: Some(true),
nulls_first: Some(true),
},
OrderByExpr {
expr: Expr::Identifier(Ident::new("fname")),
asc: Some(false),
nulls_first: Some(false),
},
],
select.order_by
);
assert_eq!(Some(Expr::Value(number("2"))), select.limit);
}
#[test]
fn parse_select_group_by() {
let sql = "SELECT id, fname, lname FROM customer GROUP BY lname, fname";
let select = verified_only_select(sql);
assert_eq!(
vec![
Expr::Identifier(Ident::new("lname")),
Expr::Identifier(Ident::new("fname")),
],
select.group_by
);
}
#[test]
fn parse_select_having() {
let sql = "SELECT foo FROM bar GROUP BY foo HAVING COUNT(*) > 1";
let select = verified_only_select(sql);
assert_eq!(
Some(Expr::BinaryOp(BinaryOp {
left: Box::new(Expr::Function(Function {
name: ObjectName(vec![Ident::new("COUNT")]),
args: vec![FunctionArg::Unnamed(Expr::Wildcard)],
over: None,
distinct: false,
})),
op: BinaryOperator::Gt,
right: Box::new(Expr::Value(number("1")))
})),
select.having
);
let sql = "SELECT 'foo' HAVING 1 = 1";
let select = verified_only_select(sql);
assert!(select.having.is_some());
}
#[test]
fn parse_limit_accepts_all() {
one_statement_parses_to(
"SELECT id, fname, lname FROM customer WHERE id = 1 LIMIT ALL",
"SELECT id, fname, lname FROM customer WHERE id = 1",
);
}
#[test]
fn parse_cast() {
let sql = "SELECT CAST(id AS BIGINT) FROM customer";
let select = verified_only_select(sql);
assert_eq!(
&Expr::Cast(Cast {
expr: Box::new(Expr::Identifier(Ident::new("id"))),
data_type: DataType::BigInt(None)
}),
expr_from_projection(only(&select.projection))
);
let sql = "SELECT CAST(id AS TINYINT) FROM customer";
let select = verified_only_select(sql);
assert_eq!(
&Expr::Cast(Cast {
expr: Box::new(Expr::Identifier(Ident::new("id"))),
data_type: DataType::TinyInt(None)
}),
expr_from_projection(only(&select.projection))
);
one_statement_parses_to(
"SELECT CAST(id AS BIGINT) FROM customer",
"SELECT CAST(id AS BIGINT) FROM customer",
);
verified_stmt("SELECT CAST(id AS NUMERIC) FROM customer");
one_statement_parses_to(
"SELECT CAST(id AS DEC) FROM customer",
"SELECT CAST(id AS NUMERIC) FROM customer",
);
one_statement_parses_to(
"SELECT CAST(id AS DECIMAL) FROM customer",
"SELECT CAST(id AS NUMERIC) FROM customer",
);
}
#[test]
fn parse_try_cast() {
let sql = "SELECT TRY_CAST(id AS BIGINT) FROM customer";
let select = verified_only_select(sql);
assert_eq!(
&Expr::TryCast(TryCast {
expr: Box::new(Expr::Identifier(Ident::new("id"))),
data_type: DataType::BigInt(None)
}),
expr_from_projection(only(&select.projection))
);
one_statement_parses_to(
"SELECT TRY_CAST(id AS BIGINT) FROM customer",
"SELECT TRY_CAST(id AS BIGINT) FROM customer",
);
verified_stmt("SELECT TRY_CAST(id AS NUMERIC) FROM customer");
one_statement_parses_to(
"SELECT TRY_CAST(id AS DEC) FROM customer",
"SELECT TRY_CAST(id AS NUMERIC) FROM customer",
);
one_statement_parses_to(
"SELECT TRY_CAST(id AS DECIMAL) FROM customer",
"SELECT TRY_CAST(id AS NUMERIC) FROM customer",
);
}
#[test]
fn parse_extract() {
let sql = "SELECT EXTRACT(YEAR FROM d)";
let select = verified_only_select(sql);
assert_eq!(
&Expr::Extract(Extract {
field: DateTimeField::Year,
expr: Box::new(Expr::Identifier(Ident::new("d"))),
}),
expr_from_projection(only(&select.projection)),
);
one_statement_parses_to("SELECT EXTRACT(year from d)", "SELECT EXTRACT(YEAR FROM d)");
verified_stmt("SELECT EXTRACT(MONTH FROM d)");
verified_stmt("SELECT EXTRACT(DAY FROM d)");
verified_stmt("SELECT EXTRACT(HOUR FROM d)");
verified_stmt("SELECT EXTRACT(MINUTE FROM d)");
verified_stmt("SELECT EXTRACT(SECOND FROM d)");
let res = parse_sql_statements("SELECT EXTRACT(MILLISECOND FROM d)");
assert_eq!(
ParserError::ParserError("Expected date/time field, found: MILLISECOND".to_string()),
res.unwrap_err()
);
}
#[test]
fn parse_listagg() {
let sql = "SELECT LISTAGG(DISTINCT dateid, ', ' ON OVERFLOW TRUNCATE '%' WITHOUT COUNT) \
WITHIN GROUP (ORDER BY id, username)";
let select = verified_only_select(sql);
verified_stmt("SELECT LISTAGG(sellerid) WITHIN GROUP (ORDER BY dateid)");
verified_stmt("SELECT LISTAGG(dateid)");
verified_stmt("SELECT LISTAGG(DISTINCT dateid)");
verified_stmt("SELECT LISTAGG(dateid ON OVERFLOW ERROR)");
verified_stmt("SELECT LISTAGG(dateid ON OVERFLOW TRUNCATE N'...' WITH COUNT)");
verified_stmt("SELECT LISTAGG(dateid ON OVERFLOW TRUNCATE X'deadbeef' WITH COUNT)");
let expr = Box::new(Expr::Identifier(Ident::new("dateid")));
let on_overflow = Some(ListAggOnOverflow::Truncate {
filler: Some(Box::new(Expr::Value(Value::SingleQuotedString(
"%".to_string(),
)))),
with_count: false,
});
let within_group = vec![
OrderByExpr {
expr: Expr::Identifier(Ident {
value: "id".to_string(),
quote_style: None,
}),
asc: None,
nulls_first: None,
},
OrderByExpr {
expr: Expr::Identifier(Ident {
value: "username".to_string(),
quote_style: None,
}),
asc: None,
nulls_first: None,
},
];
assert_eq!(
&Expr::ListAgg(ListAgg {
distinct: true,
expr,
separator: Some(Box::new(Expr::Value(Value::SingleQuotedString(
", ".to_string()
)))),
on_overflow,
within_group
}),
expr_from_projection(only(&select.projection))
);
}
#[test]
fn parse_create_table() {
let sql = "CREATE TABLE uk_cities (\
name VARCHAR(100) NOT NULL,\
lat DOUBLE NULL,\
lng DOUBLE,
constrained INTEGER NULL CONSTRAINT pkey PRIMARY KEY NOT NULL UNIQUE CHECK (constrained > 0),
ref INTEGER REFERENCES othertable (a, b),\
ref2 INTEGER references othertable2 on delete cascade on update no action,\
constraint fkey foreign key (lat) references othertable3 (lat) on delete restrict,\
constraint fkey2 foreign key (lat) references othertable4(lat) on delete no action on update restrict, \
foreign key (lat) references othertable4(lat) on update set default on delete cascade, \
FOREIGN KEY (lng) REFERENCES othertable4 (longitude) ON UPDATE SET NULL
)";
let ast = one_statement_parses_to(
sql,
"CREATE TABLE uk_cities (\
name VARCHAR(100) NOT NULL, \
lat DOUBLE PRECISION NULL, \
lng DOUBLE PRECISION, \
constrained INTEGER NULL CONSTRAINT pkey PRIMARY KEY NOT NULL UNIQUE CHECK (constrained > 0), \
ref INTEGER REFERENCES othertable (a, b), \
ref2 INTEGER REFERENCES othertable2 ON DELETE CASCADE ON UPDATE NO ACTION, \
CONSTRAINT fkey FOREIGN KEY (lat) REFERENCES othertable3(lat) ON DELETE RESTRICT, \
CONSTRAINT fkey2 FOREIGN KEY (lat) REFERENCES othertable4(lat) ON DELETE NO ACTION ON UPDATE RESTRICT, \
FOREIGN KEY (lat) REFERENCES othertable4(lat) ON DELETE CASCADE ON UPDATE SET DEFAULT, \
FOREIGN KEY (lng) REFERENCES othertable4(longitude) ON UPDATE SET NULL)",
);
match ast {
Statement::CreateTable(table) => {
let name = table.name;
let columns = table.columns;
let constraints = table.constraints;
let with_options = table.with_options;
assert!(!table.external);
assert!(!table.if_not_exists);
assert!(table.file_format.is_none());
assert!(table.location.is_none());
assert_eq!("uk_cities", name.to_string());
assert_eq!(
columns,
vec![
ColumnDef {
name: "name".into(),
data_type: DataType::Varchar(Some(100)),
collation: None,
options: vec![ColumnOptionDef {
name: None,
option: ColumnOption::NotNull
}],
},
ColumnDef {
name: "lat".into(),
data_type: DataType::Double,
collation: None,
options: vec![ColumnOptionDef {
name: None,
option: ColumnOption::Null
}],
},
ColumnDef {
name: "lng".into(),
data_type: DataType::Double,
collation: None,
options: vec![],
},
ColumnDef {
name: "constrained".into(),
data_type: DataType::Int(None),
collation: None,
options: vec![
ColumnOptionDef {
name: None,
option: ColumnOption::Null
},
ColumnOptionDef {
name: Some("pkey".into()),
option: ColumnOption::Unique { is_primary: true }
},
ColumnOptionDef {
name: None,
option: ColumnOption::NotNull
},
ColumnOptionDef {
name: None,
option: ColumnOption::Unique { is_primary: false },
},
ColumnOptionDef {
name: None,
option: ColumnOption::Check(verified_expr("constrained > 0")),
}
],
},
ColumnDef {
name: "ref".into(),
data_type: DataType::Int(None),
collation: None,
options: vec![ColumnOptionDef {
name: None,
option: ColumnOption::ForeignKey {
foreign_table: ObjectName(vec!["othertable".into()]),
referred_columns: vec!["a".into(), "b".into(),],
on_delete: None,
on_update: None,
}
}]
},
ColumnDef {
name: "ref2".into(),
data_type: DataType::Int(None),
collation: None,
options: vec![ColumnOptionDef {
name: None,
option: ColumnOption::ForeignKey {
foreign_table: ObjectName(vec!["othertable2".into()]),
referred_columns: vec![],
on_delete: Some(ReferentialAction::Cascade),
on_update: Some(ReferentialAction::NoAction),
}
},]
}
]
);
assert_eq!(
constraints,
vec![
TableConstraint::ForeignKey(ForeignKey {
name: Some("fkey".into()),
columns: vec!["lat".into()],
foreign_table: ObjectName(vec!["othertable3".into()]),
referred_columns: vec!["lat".into()],
on_delete: Some(ReferentialAction::Restrict),
on_update: None
}),
TableConstraint::ForeignKey(ForeignKey {
name: Some("fkey2".into()),
columns: vec!["lat".into()],
foreign_table: ObjectName(vec!["othertable4".into()]),
referred_columns: vec!["lat".into()],
on_delete: Some(ReferentialAction::NoAction),
on_update: Some(ReferentialAction::Restrict)
}),
TableConstraint::ForeignKey(ForeignKey {
name: None,
columns: vec!["lat".into()],
foreign_table: ObjectName(vec!["othertable4".into()]),
referred_columns: vec!["lat".into()],
on_delete: Some(ReferentialAction::Cascade),
on_update: Some(ReferentialAction::SetDefault)
}),
TableConstraint::ForeignKey(ForeignKey {
name: None,
columns: vec!["lng".into()],
foreign_table: ObjectName(vec!["othertable4".into()]),
referred_columns: vec!["longitude".into()],
on_delete: None,
on_update: Some(ReferentialAction::SetNull)
}),
]
);
assert_eq!(with_options, vec![]);
}
_ => unreachable!(),
}
let res = parse_sql_statements("CREATE TABLE t (a integer NOT NULL GARBAGE)");
assert!(res
.unwrap_err()
.to_string()
.contains("Expected \',\' or \')\' after column definition, found: GARBAGE"));
let res = parse_sql_statements("CREATE TABLE t (a integer NOT NULL CONSTRAINT foo)");
assert!(res
.unwrap_err()
.to_string()
.contains("Expected constraint details after CONSTRAINT <name>"));
}
#[test]
fn parse_create_table_with_multiple_on_delete_in_constraint_fails() {
parse_sql_statements(
"\
create table X (\
y_id int, \
foreign key (y_id) references Y (id) on delete cascade on update cascade on delete no action\
)",
)
.expect_err("should have failed");
}
#[test]
fn parse_create_table_with_multiple_on_delete_fails() {
parse_sql_statements(
"\
create table X (\
y_id int references Y (id) \
on delete cascade on update cascade on delete no action\
)",
)
.expect_err("should have failed");
}
#[test]
fn parse_assert() {
let sql = "ASSERT (SELECT COUNT(*) FROM my_table) > 0";
let ast = one_statement_parses_to(sql, "ASSERT (SELECT COUNT(*) FROM my_table) > 0");
match ast {
Statement::Assert(Assert {
condition: _condition,
message,
}) => {
assert_eq!(message, None);
}
_ => unreachable!(),
}
}
#[test]
#[allow(clippy::collapsible_match)]
fn parse_assert_message() {
let sql = "ASSERT (SELECT COUNT(*) FROM my_table) > 0 AS 'No rows in my_table'";
let ast = one_statement_parses_to(
sql,
"ASSERT (SELECT COUNT(*) FROM my_table) > 0 AS 'No rows in my_table'",
);
match ast {
Statement::Assert(Assert {
condition: _condition,
message: Some(message),
}) => {
match message {
Expr::Value(Value::SingleQuotedString(s)) => assert_eq!(s, "No rows in my_table"),
_ => unreachable!(),
};
}
_ => unreachable!(),
}
}
#[test]
fn parse_create_schema() {
let sql = "CREATE SCHEMA X";
match verified_stmt(sql) {
Statement::CreateSchema(CreateSchema { schema_name, .. }) => {
assert_eq!(schema_name.to_string(), "X".to_owned())
}
_ => unreachable!(),
}
}
#[test]
fn parse_drop_schema() {
let sql = "DROP SCHEMA X";
match verified_stmt(sql) {
Statement::Drop(Drop { object_type, .. }) => assert_eq!(object_type, ObjectType::Schema),
_ => unreachable!(),
}
}
#[test]
fn parse_create_table_as() {
let sql = "CREATE TABLE t AS SELECT * FROM a";
match verified_stmt(sql) {
Statement::CreateTable(table) => {
assert_eq!(table.name.to_string(), "t".to_string());
assert_eq!(
table.query,
Some(Box::new(verified_query("SELECT * FROM a")))
);
}
_ => unreachable!(),
}
let sql = "CREATE TABLE t (a INTEGER, b INTEGER) AS SELECT 1 AS b, 2 AS a";
match verified_stmt(sql) {
Statement::CreateTable(table) => {
let columns = table.columns;
let query = table.query;
assert_eq!(columns.len(), 2);
assert_eq!(columns[0].to_string(), "a INTEGER".to_string());
assert_eq!(columns[1].to_string(), "b INTEGER".to_string());
assert_eq!(
query,
Some(Box::new(verified_query("SELECT 1 AS b, 2 AS a")))
);
}
_ => unreachable!(),
}
}
#[test]
fn parse_create_or_replace_table() {
let sql = "CREATE OR REPLACE TABLE t (a INTEGER)";
match verified_stmt(sql) {
Statement::CreateTable(table) => {
assert_eq!(table.name.to_string(), "t".to_string());
assert!(table.or_replace);
}
_ => unreachable!(),
}
let sql = "CREATE TABLE t (a INTEGER, b INTEGER) AS SELECT 1 AS b, 2 AS a";
match verified_stmt(sql) {
Statement::CreateTable(table) => {
let columns = table.columns;
assert_eq!(columns.len(), 2);
assert_eq!(columns[0].to_string(), "a INTEGER".to_string());
assert_eq!(columns[1].to_string(), "b INTEGER".to_string());
assert_eq!(
table.query,
Some(Box::new(verified_query("SELECT 1 AS b, 2 AS a")))
);
}
_ => unreachable!(),
}
}
#[test]
fn parse_create_table_with_on_delete_on_update_2in_any_order() -> Result<(), ParserError> {
let sql = |options: &str| -> String {
format!("create table X (y_id int references Y (id) {})", options)
};
parse_sql_statements(&sql("on update cascade on delete no action"))?;
parse_sql_statements(&sql("on delete cascade on update cascade"))?;
parse_sql_statements(&sql("on update no action"))?;
parse_sql_statements(&sql("on delete restrict"))?;
Ok(())
}
#[test]
fn parse_create_table_with_options() {
let sql = "CREATE TABLE t (c INTEGER) WITH (foo = 'bar', a = 123)";
match verified_stmt(sql) {
Statement::CreateTable(table) => {
let with_options = table.with_options;
assert_eq!(
vec![
SqlOption {
name: "foo".into(),
value: Value::SingleQuotedString("bar".into())
},
SqlOption {
name: "a".into(),
value: number("123")
},
],
with_options
);
}
_ => unreachable!(),
}
}
#[test]
fn parse_create_table_trailing_comma() {
let sql = "CREATE TABLE foo (bar int,)";
all_dialects().one_statement_parses_to(sql, "CREATE TABLE foo (bar INTEGER)");
}
#[test]
fn parse_create_external_table() {
let sql = "CREATE EXTERNAL TABLE uk_cities (\
name VARCHAR(100) NOT NULL,\
lat DOUBLE NULL,\
lng DOUBLE)\
STORED AS TEXTFILE LOCATION '/tmp/example.csv'";
let ast = one_statement_parses_to(
sql,
"CREATE EXTERNAL TABLE uk_cities (\
name VARCHAR(100) NOT NULL, \
lat DOUBLE PRECISION NULL, \
lng DOUBLE PRECISION) \
STORED AS TEXTFILE LOCATION '/tmp/example.csv'",
);
match ast {
Statement::CreateTable(table) => {
let name = table.name;
let columns = table.columns;
let constraints = table.constraints;
let with_options = table.with_options;
let if_not_exists = table.if_not_exists;
let external = table.external;
let file_format = table.file_format;
let location = table.location;
assert_eq!("uk_cities", name.to_string());
assert_eq!(
columns,
vec![
ColumnDef {
name: "name".into(),
data_type: DataType::Varchar(Some(100)),
collation: None,
options: vec![ColumnOptionDef {
name: None,
option: ColumnOption::NotNull
}],
},
ColumnDef {
name: "lat".into(),
data_type: DataType::Double,
collation: None,
options: vec![ColumnOptionDef {
name: None,
option: ColumnOption::Null
}],
},
ColumnDef {
name: "lng".into(),
data_type: DataType::Double,
collation: None,
options: vec![],
},
]
);
assert!(constraints.is_empty());
assert!(external);
assert_eq!(FileFormat::TEXTFILE, file_format.unwrap());
assert_eq!("/tmp/example.csv", location.unwrap());
assert_eq!(with_options, vec![]);
assert!(!if_not_exists);
}
_ => unreachable!(),
}
}
#[test]
fn parse_create_or_replace_external_table() {
let sql = "CREATE OR REPLACE EXTERNAL TABLE uk_cities (\
name VARCHAR(100) NOT NULL)\
STORED AS TEXTFILE LOCATION '/tmp/example.csv'";
let ast = one_statement_parses_to(
sql,
"CREATE OR REPLACE EXTERNAL TABLE uk_cities (\
name VARCHAR(100) NOT NULL) \
STORED AS TEXTFILE LOCATION '/tmp/example.csv'",
);
match ast {
Statement::CreateTable(table) => {
let name = table.name;
let columns = table.columns;
let constraints = table.constraints;
let with_options = table.with_options;
let if_not_exists = table.if_not_exists;
let external = table.external;
let file_format = table.file_format;
let location = table.location;
let or_replace = table.or_replace;
assert_eq!("uk_cities", name.to_string());
assert_eq!(
columns,
vec![ColumnDef {
name: "name".into(),
data_type: DataType::Varchar(Some(100)),
collation: None,
options: vec![ColumnOptionDef {
name: None,
option: ColumnOption::NotNull
}],
},]
);
assert!(constraints.is_empty());
assert!(external);
assert_eq!(FileFormat::TEXTFILE, file_format.unwrap());
assert_eq!("/tmp/example.csv", location.unwrap());
assert_eq!(with_options, vec![]);
assert!(!if_not_exists);
assert!(or_replace);
}
_ => unreachable!(),
}
}
#[test]
fn parse_create_external_table_lowercase() {
let sql = "create external table uk_cities (\
name varchar(100) not null,\
lat double null,\
lng double)\
stored as parquet location '/tmp/example.csv'";
let ast = one_statement_parses_to(
sql,
"CREATE EXTERNAL TABLE uk_cities (\
name VARCHAR(100) NOT NULL, \
lat DOUBLE PRECISION NULL, \
lng DOUBLE PRECISION) \
STORED AS PARQUET LOCATION '/tmp/example.csv'",
);
assert_matches!(ast, Statement::CreateTable { .. });
}
#[test]
fn parse_alter_table() {
let add_column = "ALTER TABLE tab ADD COLUMN foo TEXT;";
match one_statement_parses_to(add_column, "ALTER TABLE tab ADD COLUMN foo TEXT") {
Statement::AlterTable(AlterTable {
name,
operation: AlterTableOperation::AddColumn { column_def },
}) => {
assert_eq!("tab", name.to_string());
assert_eq!("foo", column_def.name.to_string());
assert_eq!("TEXT", column_def.data_type.to_string());
}
_ => unreachable!(),
};
let rename_table = "ALTER TABLE tab RENAME TO new_tab";
match verified_stmt(rename_table) {
Statement::AlterTable(AlterTable {
name,
operation: AlterTableOperation::RenameTable { table_name },
}) => {
assert_eq!("tab", name.to_string());
assert_eq!("new_tab", table_name.to_string())
}
_ => unreachable!(),
};
let rename_column = "ALTER TABLE tab RENAME COLUMN foo TO new_foo";
match verified_stmt(rename_column) {
Statement::AlterTable(AlterTable {
name,
operation:
AlterTableOperation::RenameColumn {
old_column_name,
new_column_name,
},
}) => {
assert_eq!("tab", name.to_string());
assert_eq!(old_column_name.to_string(), "foo");
assert_eq!(new_column_name.to_string(), "new_foo");
}
_ => unreachable!(),
}
}
#[test]
fn parse_alter_table_constraints() {
check_one("CONSTRAINT address_pkey PRIMARY KEY (address_id)");
check_one("CONSTRAINT uk_task UNIQUE (report_date, task_id)");
check_one(
"CONSTRAINT customer_address_id_fkey FOREIGN KEY (address_id) \
REFERENCES public.address(address_id)",
);
check_one("CONSTRAINT ck CHECK (rtrim(ltrim(REF_CODE)) <> '')");
check_one("PRIMARY KEY (foo, bar)");
check_one("UNIQUE (id)");
check_one("FOREIGN KEY (foo, bar) REFERENCES AnotherTable(foo, bar)");
check_one("CHECK (end_date > start_date OR end_date IS NULL)");
fn check_one(constraint_text: &str) {
match verified_stmt(&format!("ALTER TABLE tab ADD {}", constraint_text)) {
Statement::AlterTable(AlterTable {
name,
operation: AlterTableOperation::AddConstraint(constraint),
}) => {
assert_eq!("tab", name.to_string());
assert_eq!(constraint_text, constraint.to_string());
}
_ => unreachable!(),
}
verified_stmt(&format!(
"CREATE TABLE foo (id INTEGER, {})",
constraint_text
));
}
}
#[test]
fn parse_alter_table_drop_column() {
check_one("DROP COLUMN IF EXISTS is_active CASCADE");
one_statement_parses_to(
"ALTER TABLE tab DROP IF EXISTS is_active CASCADE",
"ALTER TABLE tab DROP COLUMN IF EXISTS is_active CASCADE",
);
one_statement_parses_to(
"ALTER TABLE tab DROP is_active CASCADE",
"ALTER TABLE tab DROP COLUMN is_active CASCADE",
);
fn check_one(constraint_text: &str) {
match verified_stmt(&format!("ALTER TABLE tab {}", constraint_text)) {
Statement::AlterTable(AlterTable {
name,
operation:
AlterTableOperation::DropColumn {
column_name,
if_exists,
cascade,
},
}) => {
assert_eq!("tab", name.to_string());
assert_eq!("is_active", column_name.to_string());
assert!(if_exists);
assert!(cascade);
}
_ => unreachable!(),
}
}
}
#[test]
fn parse_alter_table_drop_constraint() {
let cascade = "ALTER TABLE table_name DROP CONSTRAINT constraint_name CASCADE";
let restrict = "ALTER TABLE table_name DROP CONSTRAINT constraint_name RESTRICT";
let plain = "ALTER TABLE table_name DROP CONSTRAINT constraint_name";
assert_eq!(cascade, &format!("{}", verified_stmt(cascade)));
assert_eq!(restrict, &format!("{}", verified_stmt(restrict)));
assert_eq!(plain, &format!("{}", verified_stmt(plain)));
}
#[test]
fn parse_bad_constraint() {
let res = parse_sql_statements("ALTER TABLE tab ADD");
assert_eq!(
ParserError::ParserError("Expected identifier, found: EOF".to_string()),
res.unwrap_err()
);
let res = parse_sql_statements("CREATE TABLE tab (foo int,");
assert_eq!(
ParserError::ParserError(
"Expected column name or constraint definition, found: EOF".to_string()
),
res.unwrap_err()
);
}
#[test]
fn parse_scalar_function_in_projection() {
let sql = "SELECT sqrt(id) FROM foo";
let select = verified_only_select(sql);
assert_eq!(
&Expr::Function(Function {
name: ObjectName(vec![Ident::new("sqrt")]),
args: vec![FunctionArg::Unnamed(Expr::Identifier(Ident::new("id")))],
over: None,
distinct: false,
}),
expr_from_projection(only(&select.projection))
);
}
fn run_explain_analyze(query: &str, expected_verbose: bool, expected_analyze: bool) {
match verified_stmt(query) {
Statement::Explain(Explain {
analyze,
verbose,
statement,
}) => {
assert_eq!(verbose, expected_verbose);
assert_eq!(analyze, expected_analyze);
assert_eq!("SELECT sqrt(id) FROM foo", statement.to_string());
}
_ => panic!("Unexpected Statement, must be Explain"),
}
}
#[test]
fn parse_explain_analyze_with_simple_select() {
run_explain_analyze("EXPLAIN SELECT sqrt(id) FROM foo", false, false);
run_explain_analyze("EXPLAIN VERBOSE SELECT sqrt(id) FROM foo", true, false);
run_explain_analyze("EXPLAIN ANALYZE SELECT sqrt(id) FROM foo", false, true);
run_explain_analyze(
"EXPLAIN ANALYZE VERBOSE SELECT sqrt(id) FROM foo",
true,
true,
);
}
#[test]
fn parse_named_argument_function() {
let sql = "SELECT FUN(a => '1', b => '2') FROM foo";
let select = verified_only_select(sql);
assert_eq!(
&Expr::Function(Function {
name: ObjectName(vec![Ident::new("FUN")]),
args: vec![
FunctionArg::Named {
name: Ident::new("a"),
arg: Expr::Value(Value::SingleQuotedString("1".to_owned()))
},
FunctionArg::Named {
name: Ident::new("b"),
arg: Expr::Value(Value::SingleQuotedString("2".to_owned()))
},
],
over: None,
distinct: false,
}),
expr_from_projection(only(&select.projection))
);
}
#[test]
fn parse_window_functions() {
let sql = "SELECT row_number() OVER (ORDER BY dt DESC), \
sum(foo) OVER (PARTITION BY a, b ORDER BY c, d \
ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), \
avg(bar) OVER (ORDER BY a \
RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING), \
max(baz) OVER (ORDER BY a \
ROWS UNBOUNDED PRECEDING), \
sum(qux) OVER (ORDER BY a \
GROUPS BETWEEN 1 PRECEDING AND 1 FOLLOWING) \
FROM foo";
let select = verified_only_select(sql);
assert_eq!(5, select.projection.len());
assert_eq!(
&Expr::Function(Function {
name: ObjectName(vec![Ident::new("row_number")]),
args: vec![],
over: Some(WindowSpec {
partition_by: vec![],
order_by: vec![OrderByExpr {
expr: Expr::Identifier(Ident::new("dt")),
asc: Some(false),
nulls_first: None,
}],
window_frame: None,
}),
distinct: false,
}),
expr_from_projection(&select.projection[0])
);
}
#[test]
fn parse_aggregate_with_group_by() {
let sql = "SELECT a, COUNT(1), MIN(b), MAX(b) FROM foo GROUP BY a";
let _ast = verified_only_select(sql);
}
#[test]
fn parse_literal_decimal() {
let sql = "SELECT 0.300000000000000004, 9007199254740993.0";
let select = verified_only_select(sql);
assert_eq!(2, select.projection.len());
assert_eq!(
&Expr::Value(number("0.300000000000000004")),
expr_from_projection(&select.projection[0]),
);
assert_eq!(
&Expr::Value(number("9007199254740993.0")),
expr_from_projection(&select.projection[1]),
)
}
#[test]
fn parse_literal_string() {
let sql = "SELECT 'one', N'national string', X'deadBEEF'";
let select = verified_only_select(sql);
assert_eq!(3, select.projection.len());
assert_eq!(
&Expr::Value(Value::SingleQuotedString("one".to_string())),
expr_from_projection(&select.projection[0])
);
assert_eq!(
&Expr::Value(Value::NationalStringLiteral("national string".to_string())),
expr_from_projection(&select.projection[1])
);
assert_eq!(
&Expr::Value(Value::HexStringLiteral("deadBEEF".to_string())),
expr_from_projection(&select.projection[2])
);
one_statement_parses_to("SELECT x'deadBEEF'", "SELECT X'deadBEEF'");
}
#[test]
fn parse_literal_date() {
let sql = "SELECT DATE '1999-01-01'";
let select = verified_only_select(sql);
assert_eq!(
&Expr::TypedString(TypedString {
data_type: DataType::Date,
value: "1999-01-01".into()
}),
expr_from_projection(only(&select.projection)),
);
}
#[test]
fn parse_literal_time() {
let sql = "SELECT TIME '01:23:34'";
let select = verified_only_select(sql);
assert_eq!(
&Expr::TypedString(TypedString {
data_type: DataType::Time,
value: "01:23:34".into()
}),
expr_from_projection(only(&select.projection)),
);
}
#[test]
fn parse_literal_timestamp() {
let sql = "SELECT TIMESTAMP '1999-01-01 01:23:34'";
let select = verified_only_select(sql);
assert_eq!(
&Expr::TypedString(TypedString {
data_type: DataType::Timestamp,
value: "1999-01-01 01:23:34".into()
}),
expr_from_projection(only(&select.projection)),
);
}
#[test]
fn parse_literal_interval() {
let sql = "SELECT INTERVAL '1-1' YEAR TO MONTH";
let select = verified_only_select(sql);
assert_eq!(
&Expr::Value(Value::Interval {
value: "1-1".into(),
leading_field: Some(DateTimeField::Year),
leading_precision: None,
last_field: Some(DateTimeField::Month),
fractional_seconds_precision: None,
}),
expr_from_projection(only(&select.projection)),
);
let sql = "SELECT INTERVAL '01:01.01' MINUTE (5) TO SECOND (5)";
let select = verified_only_select(sql);
assert_eq!(
&Expr::Value(Value::Interval {
value: "01:01.01".into(),
leading_field: Some(DateTimeField::Minute),
leading_precision: Some(5),
last_field: Some(DateTimeField::Second),
fractional_seconds_precision: Some(5),
}),
expr_from_projection(only(&select.projection)),
);
let sql = "SELECT INTERVAL '1' SECOND (5, 4)";
let select = verified_only_select(sql);
assert_eq!(
&Expr::Value(Value::Interval {
value: "1".into(),
leading_field: Some(DateTimeField::Second),
leading_precision: Some(5),
last_field: None,
fractional_seconds_precision: Some(4),
}),
expr_from_projection(only(&select.projection)),
);
let sql = "SELECT INTERVAL '10' HOUR";
let select = verified_only_select(sql);
assert_eq!(
&Expr::Value(Value::Interval {
value: "10".into(),
leading_field: Some(DateTimeField::Hour),
leading_precision: None,
last_field: None,
fractional_seconds_precision: None,
}),
expr_from_projection(only(&select.projection)),
);
let sql = "SELECT INTERVAL '10' HOUR (1)";
let select = verified_only_select(sql);
assert_eq!(
&Expr::Value(Value::Interval {
value: "10".into(),
leading_field: Some(DateTimeField::Hour),
leading_precision: Some(1),
last_field: None,
fractional_seconds_precision: None,
}),
expr_from_projection(only(&select.projection)),
);
let sql = "SELECT INTERVAL '1 DAY'";
let select = verified_only_select(sql);
assert_eq!(
&Expr::Value(Value::Interval {
value: "1 DAY".into(),
leading_field: None,
leading_precision: None,
last_field: None,
fractional_seconds_precision: None,
}),
expr_from_projection(only(&select.projection)),
);
let result = parse_sql_statements("SELECT INTERVAL '1' SECOND TO SECOND");
assert_eq!(
ParserError::ParserError("Expected end of statement, found: SECOND".to_string()),
result.unwrap_err(),
);
let result = parse_sql_statements("SELECT INTERVAL '10' HOUR (1) TO HOUR (2)");
assert_eq!(
ParserError::ParserError("Expected end of statement, found: (".to_string()),
result.unwrap_err(),
);
verified_only_select("SELECT INTERVAL '1' YEAR");
verified_only_select("SELECT INTERVAL '1' MONTH");
verified_only_select("SELECT INTERVAL '1' DAY");
verified_only_select("SELECT INTERVAL '1' HOUR");
verified_only_select("SELECT INTERVAL '1' MINUTE");
verified_only_select("SELECT INTERVAL '1' SECOND");
verified_only_select("SELECT INTERVAL '1' YEAR TO MONTH");
verified_only_select("SELECT INTERVAL '1' DAY TO HOUR");
verified_only_select("SELECT INTERVAL '1' DAY TO MINUTE");
verified_only_select("SELECT INTERVAL '1' DAY TO SECOND");
verified_only_select("SELECT INTERVAL '1' HOUR TO MINUTE");
verified_only_select("SELECT INTERVAL '1' HOUR TO SECOND");
verified_only_select("SELECT INTERVAL '1' MINUTE TO SECOND");
verified_only_select("SELECT INTERVAL '1 YEAR'");
verified_only_select("SELECT INTERVAL '1 YEAR' AS one_year");
one_statement_parses_to(
"SELECT INTERVAL '1 YEAR' one_year",
"SELECT INTERVAL '1 YEAR' AS one_year",
);
}
#[test]
fn parse_simple_math_expr_plus() {
let sql = "SELECT a + b, 2 + a, 2.5 + a, a_f + b_f, 2 + a_f, 2.5 + a_f FROM c";
verified_only_select(sql);
}
#[test]
fn parse_simple_math_expr_minus() {
let sql = "SELECT a - b, 2 - a, 2.5 - a, a_f - b_f, 2 - a_f, 2.5 - a_f FROM c";
verified_only_select(sql);
}
#[test]
fn parse_table_function() {
let select = verified_only_select("SELECT * FROM TABLE(FUN('1')) AS a");
match only(select.from).relation {
TableFactor::TableFunction { expr, alias } => {
let expected_expr = Expr::Function(Function {
name: ObjectName(vec![Ident::new("FUN")]),
args: vec![FunctionArg::Unnamed(Expr::Value(
Value::SingleQuotedString("1".to_owned()),
))],
over: None,
distinct: false,
});
assert_eq!(expr, expected_expr);
assert_eq!(alias, table_alias("a"))
}
_ => panic!("Expecting TableFactor::TableFunction"),
}
let res = parse_sql_statements("SELECT * FROM TABLE '1' AS a");
assert_eq!(
ParserError::ParserError("Expected (, found: \'1\'".to_string()),
res.unwrap_err()
);
let res = parse_sql_statements("SELECT * FROM TABLE (FUN(a) AS a");
assert_eq!(
ParserError::ParserError("Expected ), found: AS".to_string()),
res.unwrap_err()
);
}
#[test]
fn parse_delimited_identifiers() {
let select = verified_only_select(
r#"SELECT "alias"."bar baz", "myfun"(), "simple id" AS "column alias" FROM "a table" AS "alias""#,
);
match only(select.from).relation {
TableFactor::Table {
name,
alias,
args,
with_hints,
} => {
assert_eq!(vec![Ident::with_quote('"', "a table")], name.0);
assert_eq!(Ident::with_quote('"', "alias"), alias.unwrap().name);
assert!(args.is_empty());
assert!(with_hints.is_empty());
}
_ => panic!("Expecting TableFactor::Table"),
}
assert_eq!(3, select.projection.len());
assert_eq!(
&Expr::CompoundIdentifier(vec![
Ident::with_quote('"', "alias"),
Ident::with_quote('"', "bar baz")
]),
expr_from_projection(&select.projection[0]),
);
assert_eq!(
&Expr::Function(Function {
name: ObjectName(vec![Ident::with_quote('"', "myfun")]),
args: vec![],
over: None,
distinct: false,
}),
expr_from_projection(&select.projection[1]),
);
match &select.projection[2] {
SelectItem::ExprWithAlias { expr, alias } => {
assert_eq!(&Expr::Identifier(Ident::with_quote('"', "simple id")), expr);
assert_eq!(&Ident::with_quote('"', "column alias"), alias);
}
_ => panic!("Expected ExprWithAlias"),
}
verified_stmt(r#"CREATE TABLE "foo" ("bar" "int")"#);
verified_stmt(r#"ALTER TABLE foo ADD CONSTRAINT "bar" PRIMARY KEY (baz)"#);
}
#[test]
fn parse_parens() {
use self::BinaryOperator::*;
use Expr::{Identifier, Nested};
let sql = "(a + b) - (c + d)";
assert_eq!(
Expr::BinaryOp(BinaryOp {
left: Box::new(Nested(Box::new(Expr::BinaryOp(BinaryOp {
left: Box::new(Identifier(Ident::new("a"))),
op: Plus,
right: Box::new(Identifier(Ident::new("b")))
})))),
op: Minus,
right: Box::new(Nested(Box::new(Expr::BinaryOp(BinaryOp {
left: Box::new(Identifier(Ident::new("c"))),
op: Plus,
right: Box::new(Identifier(Ident::new("d")))
}))))
}),
verified_expr(sql)
);
}
#[test]
fn parse_searched_case_expr() {
let sql = "SELECT CASE WHEN bar IS NULL THEN 'null' WHEN bar = 0 THEN '=0' WHEN bar >= 0 THEN '>=0' ELSE '<0' END FROM foo";
use self::BinaryOperator::*;
use self::Expr::{Identifier, IsNull};
let select = verified_only_select(sql);
assert_eq!(
&Expr::Case(Case {
operand: None,
conditions: vec![
IsNull(Box::new(Identifier(Ident::new("bar")))),
Expr::BinaryOp(BinaryOp {
left: Box::new(Identifier(Ident::new("bar"))),
op: Eq,
right: Box::new(Expr::Value(number("0")))
}),
Expr::BinaryOp(BinaryOp {
left: Box::new(Identifier(Ident::new("bar"))),
op: GtEq,
right: Box::new(Expr::Value(number("0")))
})
],
results: vec![
Expr::Value(Value::SingleQuotedString("null".to_string())),
Expr::Value(Value::SingleQuotedString("=0".to_string())),
Expr::Value(Value::SingleQuotedString(">=0".to_string()))
],
else_result: Some(Box::new(Expr::Value(Value::SingleQuotedString(
"<0".to_string()
))))
}),
expr_from_projection(only(&select.projection)),
);
}
#[test]
fn parse_simple_case_expr() {
let sql = "SELECT CASE foo WHEN 1 THEN 'Y' ELSE 'N' END";
let select = verified_only_select(sql);
use self::Expr::Identifier;
assert_eq!(
&Expr::Case(Case {
operand: Some(Box::new(Identifier(Ident::new("foo")))),
conditions: vec![Expr::Value(number("1"))],
results: vec![Expr::Value(Value::SingleQuotedString("Y".to_string())),],
else_result: Some(Box::new(Expr::Value(Value::SingleQuotedString(
"N".to_string()
))))
}),
expr_from_projection(only(&select.projection)),
);
}
#[test]
fn parse_from_advanced() {
let sql = "SELECT * FROM fn(1, 2) AS foo, schema.bar AS bar WITH (NOLOCK)";
let _select = verified_only_select(sql);
}
#[test]
fn parse_implicit_join() {
let sql = "SELECT * FROM t1, t2";
let select = verified_only_select(sql);
assert_eq!(
vec![
TableWithJoins {
relation: TableFactor::Table {
name: ObjectName(vec!["t1".into()]),
alias: None,
args: vec![],
with_hints: vec![],
},
joins: vec![],
},
TableWithJoins {
relation: TableFactor::Table {
name: ObjectName(vec!["t2".into()]),
alias: None,
args: vec![],
with_hints: vec![],
},
joins: vec![],
}
],
select.from,
);
let sql = "SELECT * FROM t1a NATURAL JOIN t1b, t2a NATURAL JOIN t2b";
let select = verified_only_select(sql);
assert_eq!(
vec![
TableWithJoins {
relation: TableFactor::Table {
name: ObjectName(vec!["t1a".into()]),
alias: None,
args: vec![],
with_hints: vec![],
},
joins: vec![Join {
relation: TableFactor::Table {
name: ObjectName(vec!["t1b".into()]),
alias: None,
args: vec![],
with_hints: vec![],
},
join_operator: JoinOperator::Inner(JoinConstraint::Natural),
}]
},
TableWithJoins {
relation: TableFactor::Table {
name: ObjectName(vec!["t2a".into()]),
alias: None,
args: vec![],
with_hints: vec![],
},
joins: vec![Join {
relation: TableFactor::Table {
name: ObjectName(vec!["t2b".into()]),
alias: None,
args: vec![],
with_hints: vec![],
},
join_operator: JoinOperator::Inner(JoinConstraint::Natural),
}]
}
],
select.from,
);
}
#[test]
fn parse_cross_join() {
let sql = "SELECT * FROM t1 CROSS JOIN t2";
let select = verified_only_select(sql);
assert_eq!(
Join {
relation: TableFactor::Table {
name: ObjectName(vec![Ident::new("t2")]),
alias: None,
args: vec![],
with_hints: vec![],
},
join_operator: JoinOperator::CrossJoin
},
only(only(select.from).joins),
);
}
#[test]
fn parse_joins_on() {
fn join_with_constraint(
relation: impl Into<String>,
alias: Option<TableAlias>,
f: impl Fn(JoinConstraint) -> JoinOperator,
) -> Join {
Join {
relation: TableFactor::Table {
name: ObjectName(vec![Ident::new(relation.into())]),
alias,
args: vec![],
with_hints: vec![],
},
join_operator: f(JoinConstraint::On(Expr::BinaryOp(BinaryOp {
left: Box::new(Expr::Identifier("c1".into())),
op: BinaryOperator::Eq,
right: Box::new(Expr::Identifier("c2".into())),
}))),
}
}
assert_eq!(
only(&verified_only_select("SELECT * FROM t1 JOIN t2 AS foo ON c1 = c2").from).joins,
vec![join_with_constraint(
"t2",
table_alias("foo"),
JoinOperator::Inner
)]
);
one_statement_parses_to(
"SELECT * FROM t1 JOIN t2 foo ON c1 = c2",
"SELECT * FROM t1 JOIN t2 AS foo ON c1 = c2",
);
assert_eq!(
only(&verified_only_select("SELECT * FROM t1 JOIN t2 ON c1 = c2").from).joins,
vec![join_with_constraint("t2", None, JoinOperator::Inner)]
);
assert_eq!(
only(&verified_only_select("SELECT * FROM t1 LEFT JOIN t2 ON c1 = c2").from).joins,
vec![join_with_constraint("t2", None, JoinOperator::LeftOuter)]
);
assert_eq!(
only(&verified_only_select("SELECT * FROM t1 RIGHT JOIN t2 ON c1 = c2").from).joins,
vec![join_with_constraint("t2", None, JoinOperator::RightOuter)]
);
assert_eq!(
only(&verified_only_select("SELECT * FROM t1 FULL JOIN t2 ON c1 = c2").from).joins,
vec![join_with_constraint("t2", None, JoinOperator::FullOuter)]
);
}
#[test]
fn parse_joins_using() {
fn join_with_constraint(
relation: impl Into<String>,
alias: Option<TableAlias>,
f: impl Fn(JoinConstraint) -> JoinOperator,
) -> Join {
Join {
relation: TableFactor::Table {
name: ObjectName(vec![Ident::new(relation.into())]),
alias,
args: vec![],
with_hints: vec![],
},
join_operator: f(JoinConstraint::Using(vec!["c1".into()])),
}
}
assert_eq!(
only(&verified_only_select("SELECT * FROM t1 JOIN t2 AS foo USING(c1)").from).joins,
vec![join_with_constraint(
"t2",
table_alias("foo"),
JoinOperator::Inner
)]
);
one_statement_parses_to(
"SELECT * FROM t1 JOIN t2 foo USING(c1)",
"SELECT * FROM t1 JOIN t2 AS foo USING(c1)",
);
assert_eq!(
only(&verified_only_select("SELECT * FROM t1 JOIN t2 USING(c1)").from).joins,
vec![join_with_constraint("t2", None, JoinOperator::Inner)]
);
assert_eq!(
only(&verified_only_select("SELECT * FROM t1 LEFT JOIN t2 USING(c1)").from).joins,
vec![join_with_constraint("t2", None, JoinOperator::LeftOuter)]
);
assert_eq!(
only(&verified_only_select("SELECT * FROM t1 RIGHT JOIN t2 USING(c1)").from).joins,
vec![join_with_constraint("t2", None, JoinOperator::RightOuter)]
);
assert_eq!(
only(&verified_only_select("SELECT * FROM t1 FULL JOIN t2 USING(c1)").from).joins,
vec![join_with_constraint("t2", None, JoinOperator::FullOuter)]
);
}
#[test]
fn parse_natural_join() {
fn natural_join(f: impl Fn(JoinConstraint) -> JoinOperator) -> Join {
Join {
relation: TableFactor::Table {
name: ObjectName(vec![Ident::new("t2")]),
alias: None,
args: vec![],
with_hints: vec![],
},
join_operator: f(JoinConstraint::Natural),
}
}
assert_eq!(
only(&verified_only_select("SELECT * FROM t1 NATURAL JOIN t2").from).joins,
vec![natural_join(JoinOperator::Inner)]
);
assert_eq!(
only(&verified_only_select("SELECT * FROM t1 NATURAL LEFT JOIN t2").from).joins,
vec![natural_join(JoinOperator::LeftOuter)]
);
assert_eq!(
only(&verified_only_select("SELECT * FROM t1 NATURAL RIGHT JOIN t2").from).joins,
vec![natural_join(JoinOperator::RightOuter)]
);
assert_eq!(
only(&verified_only_select("SELECT * FROM t1 NATURAL FULL JOIN t2").from).joins,
vec![natural_join(JoinOperator::FullOuter)]
);
let sql = "SELECT * FROM t1 natural";
assert_eq!(
ParserError::ParserError("Expected a join type after NATURAL, found: EOF".to_string()),
parse_sql_statements(sql).unwrap_err(),
);
}
#[test]
fn parse_complex_join() {
let sql = "SELECT c1, c2 FROM t1, t4 JOIN t2 ON t2.c = t1.c LEFT JOIN t3 USING(q, c) WHERE t4.c = t1.c";
verified_only_select(sql);
}
#[test]
fn parse_join_nesting() {
let sql = "SELECT * FROM a NATURAL JOIN (b NATURAL JOIN (c NATURAL JOIN d NATURAL JOIN e)) \
NATURAL JOIN (f NATURAL JOIN (g NATURAL JOIN h))";
assert_eq!(
only(&verified_only_select(sql).from).joins,
vec![
join(nest!(table("b"), nest!(table("c"), table("d"), table("e")))),
join(nest!(table("f"), nest!(table("g"), table("h"))))
],
);
let sql = "SELECT * FROM (a NATURAL JOIN b) NATURAL JOIN c";
let select = verified_only_select(sql);
let from = only(select.from);
assert_eq!(from.relation, nest!(table("a"), table("b")));
assert_eq!(from.joins, vec![join(table("c"))]);
let sql = "SELECT * FROM (((a NATURAL JOIN b)))";
let select = verified_only_select(sql);
let from = only(select.from);
assert_eq!(from.relation, nest!(nest!(nest!(table("a"), table("b")))));
assert_eq!(from.joins, vec![]);
let sql = "SELECT * FROM a NATURAL JOIN (((b NATURAL JOIN c)))";
let select = verified_only_select(sql);
let from = only(select.from);
assert_eq!(from.relation, table("a"));
assert_eq!(
from.joins,
vec![join(nest!(nest!(nest!(table("b"), table("c")))))]
);
}
#[test]
fn parse_join_syntax_variants() {
one_statement_parses_to(
"SELECT c1 FROM t1 INNER JOIN t2 USING(c1)",
"SELECT c1 FROM t1 JOIN t2 USING(c1)",
);
one_statement_parses_to(
"SELECT c1 FROM t1 LEFT OUTER JOIN t2 USING(c1)",
"SELECT c1 FROM t1 LEFT JOIN t2 USING(c1)",
);
one_statement_parses_to(
"SELECT c1 FROM t1 RIGHT OUTER JOIN t2 USING(c1)",
"SELECT c1 FROM t1 RIGHT JOIN t2 USING(c1)",
);
one_statement_parses_to(
"SELECT c1 FROM t1 FULL OUTER JOIN t2 USING(c1)",
"SELECT c1 FROM t1 FULL JOIN t2 USING(c1)",
);
let res = parse_sql_statements("SELECT * FROM a OUTER JOIN b ON 1");
assert_eq!(
ParserError::ParserError("Expected APPLY, found: JOIN".to_string()),
res.unwrap_err()
);
}
#[test]
fn parse_ctes() {
let cte_sqls = vec!["SELECT 1 AS foo", "SELECT 2 AS bar"];
let with = &format!(
"WITH a AS ({}), b AS ({}) SELECT foo + bar FROM a, b",
cte_sqls[0], cte_sqls[1]
);
fn assert_ctes_in_select(expected: &[&str], sel: &Query) {
for (i, exp) in expected.iter().enumerate() {
let Cte { alias, query, .. } = &sel.with.as_ref().unwrap().cte_tables[i];
assert_eq!(*exp, query.to_string());
assert_eq!(
if i == 0 {
Ident::new("a")
} else {
Ident::new("b")
},
alias.name
);
assert!(alias.columns.is_empty());
}
}
assert_ctes_in_select(&cte_sqls, &verified_query(with));
let sql = &format!("SELECT ({})", with);
let select = verified_only_select(sql);
match expr_from_projection(only(&select.projection)) {
Expr::Subquery(ref subquery) => {
assert_ctes_in_select(&cte_sqls, subquery.as_ref());
}
_ => panic!("Expected subquery"),
}
let sql = &format!("SELECT * FROM ({})", with);
let select = verified_only_select(sql);
match only(select.from).relation {
TableFactor::Derived { subquery, .. } => {
assert_ctes_in_select(&cte_sqls, subquery.as_ref())
}
_ => panic!("Expected derived table"),
}
let sql = &format!("CREATE VIEW v AS {}", with);
match verified_stmt(sql) {
Statement::CreateView(CreateView { query, .. }) => assert_ctes_in_select(&cte_sqls, &query),
_ => panic!("Expected CREATE VIEW"),
}
let sql = &format!("WITH outer_cte AS ({}) SELECT * FROM outer_cte", with);
let select = verified_query(sql);
assert_ctes_in_select(&cte_sqls, &only(&select.with.unwrap().cte_tables).query);
}
#[test]
fn parse_cte_renamed_columns() {
let sql = "WITH cte (col1, col2) AS (SELECT foo, bar FROM baz) SELECT * FROM cte";
let query = all_dialects().verified_query(sql);
assert_eq!(
vec![Ident::new("col1"), Ident::new("col2")],
query
.with
.unwrap()
.cte_tables
.first()
.unwrap()
.alias
.columns
);
}
#[test]
fn parse_recursive_cte() {
let cte_query = "SELECT 1 UNION ALL SELECT val + 1 FROM nums WHERE val < 10".to_owned();
let sql = &format!(
"WITH RECURSIVE nums (val) AS ({}) SELECT * FROM nums",
cte_query
);
let cte_query = verified_query(&cte_query);
let query = verified_query(sql);
let with = query.with.as_ref().unwrap();
assert!(with.recursive);
assert_eq!(with.cte_tables.len(), 1);
let expected = Cte {
alias: TableAlias {
name: Ident {
value: "nums".to_string(),
quote_style: None,
},
columns: vec![Ident {
value: "val".to_string(),
quote_style: None,
}],
},
query: cte_query,
from: None,
};
assert_eq!(with.cte_tables.first().unwrap(), &expected);
}
#[test]
fn parse_derived_tables() {
let sql = "SELECT a.x, b.y FROM (SELECT x FROM foo) AS a CROSS JOIN (SELECT y FROM bar) AS b";
let _ = verified_only_select(sql);
let sql = "SELECT a.x, b.y \
FROM (SELECT x FROM foo) AS a (x) \
CROSS JOIN (SELECT y FROM bar) AS b (y)";
let _ = verified_only_select(sql);
let sql = "SELECT * FROM (((SELECT 1)))";
let _ = verified_only_select(sql);
let sql = "SELECT * FROM t NATURAL JOIN (((SELECT 1)))";
let _ = verified_only_select(sql);
let sql = "SELECT * FROM (((SELECT 1) UNION (SELECT 2)) AS t1 NATURAL JOIN t2)";
let select = verified_only_select(sql);
let from = only(select.from);
assert_eq!(
from.relation,
TableFactor::NestedJoin(Box::new(TableWithJoins {
relation: TableFactor::Derived {
lateral: false,
subquery: Box::new(verified_query("(SELECT 1) UNION (SELECT 2)")),
alias: Some(TableAlias {
name: "t1".into(),
columns: vec![],
})
},
joins: vec![Join {
relation: TableFactor::Table {
name: ObjectName(vec!["t2".into()]),
alias: None,
args: vec![],
with_hints: vec![],
},
join_operator: JoinOperator::Inner(JoinConstraint::Natural),
}],
}))
);
}
#[test]
fn parse_union() {
verified_stmt("SELECT 1 UNION SELECT 2");
verified_stmt("SELECT 1 UNION ALL SELECT 2");
verified_stmt("SELECT 1 EXCEPT SELECT 2");
verified_stmt("SELECT 1 EXCEPT ALL SELECT 2");
verified_stmt("SELECT 1 INTERSECT SELECT 2");
verified_stmt("SELECT 1 INTERSECT ALL SELECT 2");
verified_stmt("SELECT 1 UNION SELECT 2 UNION SELECT 3");
verified_stmt("SELECT 1 EXCEPT SELECT 2 UNION SELECT 3"); verified_stmt("SELECT 1 INTERSECT (SELECT 2 EXCEPT SELECT 3)");
verified_stmt("WITH cte AS (SELECT 1 AS foo) (SELECT foo FROM cte ORDER BY 1 LIMIT 1)");
verified_stmt("SELECT 1 UNION (SELECT 2 ORDER BY 1 LIMIT 1)");
verified_stmt("SELECT 1 UNION SELECT 2 INTERSECT SELECT 3"); verified_stmt("SELECT foo FROM tab UNION SELECT bar FROM TAB");
verified_stmt("(SELECT * FROM new EXCEPT SELECT * FROM old) UNION ALL (SELECT * FROM old EXCEPT SELECT * FROM new) ORDER BY 1");
}
#[test]
fn parse_values() {
verified_stmt("SELECT * FROM (VALUES (1), (2), (3))");
verified_stmt("SELECT * FROM (VALUES (1), (2), (3)), (VALUES (1, 2, 3))");
verified_stmt("SELECT * FROM (VALUES (1)) UNION VALUES (1)");
}
#[test]
fn parse_multiple_statements() {
fn test_with(sql1: &str, sql2_kw: &str, sql2_rest: &str) {
let res = parse_sql_statements(&(sql1.to_owned() + ";" + sql2_kw + sql2_rest));
assert_eq!(
vec![
one_statement_parses_to(sql1, ""),
one_statement_parses_to(&(sql2_kw.to_owned() + sql2_rest), ""),
],
res.unwrap()
);
one_statement_parses_to(&(sql1.to_owned() + ";"), sql1);
let res = parse_sql_statements(&(sql1.to_owned() + " " + sql2_kw + sql2_rest));
assert_eq!(
ParserError::ParserError("Expected end of statement, found: ".to_string() + sql2_kw),
res.unwrap_err()
);
}
test_with("SELECT foo", "SELECT", " bar");
test_with("SELECT foo FROM baz", "SELECT", " bar");
test_with("SELECT foo", "WITH", " cte AS (SELECT 1 AS s) SELECT bar");
test_with(
"SELECT foo FROM baz",
"WITH",
" cte AS (SELECT 1 AS s) SELECT bar",
);
test_with("DELETE FROM foo", "SELECT", " bar");
test_with("INSERT INTO foo VALUES (1)", "SELECT", " bar");
test_with("CREATE TABLE foo (baz INTEGER)", "SELECT", " bar");
let res = parse_sql_statements(";;");
assert_eq!(0, res.unwrap().len());
}
#[test]
fn parse_scalar_subqueries() {
let sql = "(SELECT 1) + (SELECT 2)";
assert_matches!(
verified_expr(sql),
Expr::BinaryOp(BinaryOp {
op: BinaryOperator::Plus, ..
})
);
}
#[test]
fn parse_substring() {
one_statement_parses_to("SELECT SUBSTRING('1')", "SELECT SUBSTRING('1')");
one_statement_parses_to(
"SELECT SUBSTRING('1' FROM 1)",
"SELECT SUBSTRING('1' FROM 1)",
);
one_statement_parses_to(
"SELECT SUBSTRING('1' FROM 1 FOR 3)",
"SELECT SUBSTRING('1' FROM 1 FOR 3)",
);
one_statement_parses_to("SELECT SUBSTRING('1' FOR 3)", "SELECT SUBSTRING('1' FOR 3)");
}
#[test]
fn parse_trim() {
one_statement_parses_to(
"SELECT TRIM(BOTH 'xyz' FROM 'xyzfooxyz')",
"SELECT TRIM(BOTH 'xyz' FROM 'xyzfooxyz')",
);
one_statement_parses_to(
"SELECT TRIM(LEADING 'xyz' FROM 'xyzfooxyz')",
"SELECT TRIM(LEADING 'xyz' FROM 'xyzfooxyz')",
);
one_statement_parses_to(
"SELECT TRIM(TRAILING 'xyz' FROM 'xyzfooxyz')",
"SELECT TRIM(TRAILING 'xyz' FROM 'xyzfooxyz')",
);
one_statement_parses_to("SELECT TRIM(' foo ')", "SELECT TRIM(' foo ')");
assert_eq!(
ParserError::ParserError("Expected ), found: 'xyz'".to_owned()),
parse_sql_statements("SELECT TRIM(FOO 'xyz' FROM 'xyzfooxyz')").unwrap_err()
);
}
#[test]
fn parse_exists_subquery() {
let expected_inner = verified_query("SELECT 1");
let sql = "SELECT * FROM t WHERE EXISTS (SELECT 1)";
let select = verified_only_select(sql);
assert_eq!(
Expr::Exists(Box::new(expected_inner.clone())),
select.selection.unwrap(),
);
let sql = "SELECT * FROM t WHERE NOT EXISTS (SELECT 1)";
let select = verified_only_select(sql);
assert_eq!(
Expr::UnaryOp(UnaryOp {
op: UnaryOperator::Not,
expr: Box::new(Expr::Exists(Box::new(expected_inner))),
}),
select.selection.unwrap(),
);
verified_stmt("SELECT * FROM t WHERE EXISTS (WITH u AS (SELECT 1) SELECT * FROM u)");
verified_stmt("SELECT EXISTS (SELECT 1)");
let res = parse_sql_statements("SELECT EXISTS (");
assert_eq!(
ParserError::ParserError(
"Expected SELECT, VALUES, or a subquery in the query body, found: EOF".to_string()
),
res.unwrap_err(),
);
let res = parse_sql_statements("SELECT EXISTS (NULL)");
assert_eq!(
ParserError::ParserError(
"Expected SELECT, VALUES, or a subquery in the query body, found: NULL".to_string()
),
res.unwrap_err(),
);
}
#[test]
fn parse_create_view() {
let sql = "CREATE VIEW myschema.myview AS SELECT foo FROM bar";
match verified_stmt(sql) {
Statement::CreateView(CreateView {
name,
columns,
query,
or_replace,
materialized,
with_options,
}) => {
assert_eq!("myschema.myview", name.to_string());
assert_eq!(Vec::<Ident>::new(), columns);
assert_eq!("SELECT foo FROM bar", query.to_string());
assert!(!materialized);
assert!(!or_replace);
assert_eq!(with_options, vec![]);
}
_ => unreachable!(),
}
}
#[test]
fn parse_create_view_with_options() {
let sql = "CREATE VIEW v WITH (foo = 'bar', a = 123) AS SELECT 1";
match verified_stmt(sql) {
Statement::CreateView(CreateView { with_options, .. }) => {
assert_eq!(
vec![
SqlOption {
name: "foo".into(),
value: Value::SingleQuotedString("bar".into())
},
SqlOption {
name: "a".into(),
value: number("123")
},
],
with_options
);
}
_ => unreachable!(),
}
}
#[test]
fn parse_create_view_with_columns() {
let sql = "CREATE VIEW v (has, cols) AS SELECT 1, 2";
match verified_stmt(sql) {
Statement::CreateView(CreateView {
name,
columns,
or_replace,
with_options,
query,
materialized,
}) => {
assert_eq!("v", name.to_string());
assert_eq!(columns, vec![Ident::new("has"), Ident::new("cols")]);
assert_eq!(with_options, vec![]);
assert_eq!("SELECT 1, 2", query.to_string());
assert!(!materialized);
assert!(!or_replace)
}
_ => unreachable!(),
}
}
#[test]
fn parse_create_or_replace_view() {
let sql = "CREATE OR REPLACE VIEW v AS SELECT 1";
match verified_stmt(sql) {
Statement::CreateView(CreateView {
name,
columns,
or_replace,
with_options,
query,
materialized,
}) => {
assert_eq!("v", name.to_string());
assert_eq!(columns, vec![]);
assert_eq!(with_options, vec![]);
assert_eq!("SELECT 1", query.to_string());
assert!(!materialized);
assert!(or_replace)
}
_ => unreachable!(),
}
}
#[test]
fn parse_create_or_replace_materialized_view() {
let sql = "CREATE OR REPLACE MATERIALIZED VIEW v AS SELECT 1";
match verified_stmt(sql) {
Statement::CreateView(CreateView {
name,
columns,
or_replace,
with_options,
query,
materialized,
}) => {
assert_eq!("v", name.to_string());
assert_eq!(columns, vec![]);
assert_eq!(with_options, vec![]);
assert_eq!("SELECT 1", query.to_string());
assert!(materialized);
assert!(or_replace)
}
_ => unreachable!(),
}
}
#[test]
fn parse_create_materialized_view() {
let sql = "CREATE MATERIALIZED VIEW myschema.myview AS SELECT foo FROM bar";
match verified_stmt(sql) {
Statement::CreateView(CreateView {
name,
or_replace,
columns,
query,
materialized,
with_options,
}) => {
assert_eq!("myschema.myview", name.to_string());
assert_eq!(Vec::<Ident>::new(), columns);
assert_eq!("SELECT foo FROM bar", query.to_string());
assert!(materialized);
assert_eq!(with_options, vec![]);
assert!(!or_replace);
}
_ => unreachable!(),
}
}
#[test]
fn parse_drop_table() {
let sql = "DROP TABLE foo";
match verified_stmt(sql) {
Statement::Drop(Drop {
object_type,
if_exists,
names,
cascade,
purge: _,
}) => {
assert!(!if_exists);
assert_eq!(ObjectType::Table, object_type);
assert_eq!(
vec!["foo"],
names.iter().map(ToString::to_string).collect::<Vec<_>>()
);
assert!(!cascade);
}
_ => unreachable!(),
}
let sql = "DROP TABLE IF EXISTS foo, bar CASCADE";
match verified_stmt(sql) {
Statement::Drop(Drop {
object_type,
if_exists,
names,
cascade,
purge: _,
}) => {
assert!(if_exists);
assert_eq!(ObjectType::Table, object_type);
assert_eq!(
vec!["foo", "bar"],
names.iter().map(ToString::to_string).collect::<Vec<_>>()
);
assert!(cascade);
}
_ => unreachable!(),
}
let sql = "DROP TABLE";
assert_eq!(
ParserError::ParserError("Expected identifier, found: EOF".to_string()),
parse_sql_statements(sql).unwrap_err(),
);
let sql = "DROP TABLE IF EXISTS foo, bar CASCADE RESTRICT";
assert_eq!(
ParserError::ParserError("Cannot specify both CASCADE and RESTRICT in DROP".to_string()),
parse_sql_statements(sql).unwrap_err(),
);
}
#[test]
fn parse_drop_view() {
let sql = "DROP VIEW myschema.myview";
match verified_stmt(sql) {
Statement::Drop(Drop {
names, object_type, ..
}) => {
assert_eq!(
vec!["myschema.myview"],
names.iter().map(ToString::to_string).collect::<Vec<_>>()
);
assert_eq!(ObjectType::View, object_type);
}
_ => unreachable!(),
}
}
#[test]
fn parse_invalid_subquery_without_parens() {
let res = parse_sql_statements("SELECT SELECT 1 FROM bar WHERE 1=1 FROM baz");
assert_eq!(
ParserError::ParserError("Expected end of statement, found: 1".to_string()),
res.unwrap_err()
);
}
#[test]
fn parse_offset() {
let expect = Some(Offset {
value: Expr::Value(number("2")),
rows: OffsetRows::Rows,
});
let ast = verified_query("SELECT foo FROM bar OFFSET 2 ROWS");
assert_eq!(ast.offset, expect);
let ast = verified_query("SELECT foo FROM bar WHERE foo = 4 OFFSET 2 ROWS");
assert_eq!(ast.offset, expect);
let ast = verified_query("SELECT foo FROM bar ORDER BY baz OFFSET 2 ROWS");
assert_eq!(ast.offset, expect);
let ast = verified_query("SELECT foo FROM bar WHERE foo = 4 ORDER BY baz OFFSET 2 ROWS");
assert_eq!(ast.offset, expect);
let ast = verified_query("SELECT foo FROM (SELECT * FROM bar OFFSET 2 ROWS) OFFSET 2 ROWS");
assert_eq!(ast.offset, expect);
match ast.body {
SetExpr::Select(s) => match only(s.from).relation {
TableFactor::Derived { subquery, .. } => {
assert_eq!(subquery.offset, expect);
}
_ => panic!("Test broke"),
},
_ => panic!("Test broke"),
}
let ast = verified_query("SELECT 'foo' OFFSET 0 ROWS");
assert_eq!(
ast.offset,
Some(Offset {
value: Expr::Value(number("0")),
rows: OffsetRows::Rows,
})
);
let ast = verified_query("SELECT 'foo' OFFSET 1 ROW");
assert_eq!(
ast.offset,
Some(Offset {
value: Expr::Value(number("1")),
rows: OffsetRows::Row,
})
);
let ast = verified_query("SELECT 'foo' OFFSET 1");
assert_eq!(
ast.offset,
Some(Offset {
value: Expr::Value(number("1")),
rows: OffsetRows::None,
})
);
}
#[test]
fn parse_fetch() {
let fetch_first_two_rows_only = Some(Fetch {
with_ties: false,
percent: false,
quantity: Some(Expr::Value(number("2"))),
});
let ast = verified_query("SELECT foo FROM bar FETCH FIRST 2 ROWS ONLY");
assert_eq!(ast.fetch, fetch_first_two_rows_only);
let ast = verified_query("SELECT 'foo' FETCH FIRST 2 ROWS ONLY");
assert_eq!(ast.fetch, fetch_first_two_rows_only);
let ast = verified_query("SELECT foo FROM bar FETCH FIRST ROWS ONLY");
assert_eq!(
ast.fetch,
Some(Fetch {
with_ties: false,
percent: false,
quantity: None,
})
);
let ast = verified_query("SELECT foo FROM bar WHERE foo = 4 FETCH FIRST 2 ROWS ONLY");
assert_eq!(ast.fetch, fetch_first_two_rows_only);
let ast = verified_query("SELECT foo FROM bar ORDER BY baz FETCH FIRST 2 ROWS ONLY");
assert_eq!(ast.fetch, fetch_first_two_rows_only);
let ast = verified_query(
"SELECT foo FROM bar WHERE foo = 4 ORDER BY baz FETCH FIRST 2 ROWS WITH TIES",
);
assert_eq!(
ast.fetch,
Some(Fetch {
with_ties: true,
percent: false,
quantity: Some(Expr::Value(number("2"))),
})
);
let ast = verified_query("SELECT foo FROM bar FETCH FIRST 50 PERCENT ROWS ONLY");
assert_eq!(
ast.fetch,
Some(Fetch {
with_ties: false,
percent: true,
quantity: Some(Expr::Value(number("50"))),
})
);
let ast = verified_query(
"SELECT foo FROM bar WHERE foo = 4 ORDER BY baz OFFSET 2 ROWS FETCH FIRST 2 ROWS ONLY",
);
assert_eq!(
ast.offset,
Some(Offset {
value: Expr::Value(number("2")),
rows: OffsetRows::Rows,
})
);
assert_eq!(ast.fetch, fetch_first_two_rows_only);
let ast = verified_query(
"SELECT foo FROM (SELECT * FROM bar FETCH FIRST 2 ROWS ONLY) FETCH FIRST 2 ROWS ONLY",
);
assert_eq!(ast.fetch, fetch_first_two_rows_only);
match ast.body {
SetExpr::Select(s) => match only(s.from).relation {
TableFactor::Derived { subquery, .. } => {
assert_eq!(subquery.fetch, fetch_first_two_rows_only);
}
_ => panic!("Test broke"),
},
_ => panic!("Test broke"),
}
let ast = verified_query("SELECT foo FROM (SELECT * FROM bar OFFSET 2 ROWS FETCH FIRST 2 ROWS ONLY) OFFSET 2 ROWS FETCH FIRST 2 ROWS ONLY");
assert_eq!(
ast.offset,
Some(Offset {
value: Expr::Value(number("2")),
rows: OffsetRows::Rows,
})
);
assert_eq!(ast.fetch, fetch_first_two_rows_only);
match ast.body {
SetExpr::Select(s) => match only(s.from).relation {
TableFactor::Derived { subquery, .. } => {
assert_eq!(
subquery.offset,
Some(Offset {
value: Expr::Value(number("2")),
rows: OffsetRows::Rows,
})
);
assert_eq!(subquery.fetch, fetch_first_two_rows_only);
}
_ => panic!("Test broke"),
},
_ => panic!("Test broke"),
}
}
#[test]
fn parse_fetch_variations() {
one_statement_parses_to(
"SELECT foo FROM bar FETCH FIRST 10 ROW ONLY",
"SELECT foo FROM bar FETCH FIRST 10 ROWS ONLY",
);
one_statement_parses_to(
"SELECT foo FROM bar FETCH NEXT 10 ROW ONLY",
"SELECT foo FROM bar FETCH FIRST 10 ROWS ONLY",
);
one_statement_parses_to(
"SELECT foo FROM bar FETCH NEXT 10 ROWS WITH TIES",
"SELECT foo FROM bar FETCH FIRST 10 ROWS WITH TIES",
);
one_statement_parses_to(
"SELECT foo FROM bar FETCH NEXT ROWS WITH TIES",
"SELECT foo FROM bar FETCH FIRST ROWS WITH TIES",
);
one_statement_parses_to(
"SELECT foo FROM bar FETCH FIRST ROWS ONLY",
"SELECT foo FROM bar FETCH FIRST ROWS ONLY",
);
}
#[test]
fn lateral_derived() {
fn chk(lateral_in: bool) {
let lateral_str = if lateral_in { "LATERAL " } else { "" };
let sql = format!(
"SELECT * FROM customer LEFT JOIN {}\
(SELECT * FROM order WHERE order.customer = customer.id LIMIT 3) AS order ON true",
lateral_str
);
let select = verified_only_select(&sql);
let from = only(select.from);
assert_eq!(from.joins.len(), 1);
let join = &from.joins[0];
assert_eq!(
join.join_operator,
JoinOperator::LeftOuter(JoinConstraint::On(Expr::Value(Value::Boolean(true))))
);
if let TableFactor::Derived {
lateral,
ref subquery,
alias: Some(ref alias),
} = join.relation
{
assert_eq!(lateral_in, lateral);
assert_eq!(Ident::new("order"), alias.name);
assert_eq!(
subquery.to_string(),
"SELECT * FROM order WHERE order.customer = customer.id LIMIT 3"
);
} else {
unreachable!()
}
}
chk(false);
chk(true);
let sql = "SELECT * FROM customer LEFT JOIN LATERAL generate_series(1, customer.id)";
let res = parse_sql_statements(sql);
assert_eq!(
ParserError::ParserError(
"Expected subquery after LATERAL, found: generate_series".to_string()
),
res.unwrap_err()
);
let sql = "SELECT * FROM a LEFT JOIN LATERAL (b CROSS JOIN c)";
let res = parse_sql_statements(sql);
assert_eq!(
ParserError::ParserError(
"Expected SELECT, VALUES, or a subquery in the query body, found: b".to_string()
),
res.unwrap_err()
);
}
#[test]
fn parse_start_transaction() {
match verified_stmt("START TRANSACTION READ ONLY, READ WRITE, ISOLATION LEVEL SERIALIZABLE") {
Statement::StartTransaction(StartTransaction { modes }) => assert_eq!(
modes,
vec![
TransactionMode::AccessMode(TransactionAccessMode::ReadOnly),
TransactionMode::AccessMode(TransactionAccessMode::ReadWrite),
TransactionMode::IsolationLevel(TransactionIsolationLevel::Serializable),
]
),
_ => unreachable!(),
}
match one_statement_parses_to(
"START TRANSACTION READ ONLY READ WRITE ISOLATION LEVEL SERIALIZABLE",
"START TRANSACTION READ ONLY, READ WRITE, ISOLATION LEVEL SERIALIZABLE",
) {
Statement::StartTransaction(StartTransaction { modes }) => assert_eq!(
modes,
vec![
TransactionMode::AccessMode(TransactionAccessMode::ReadOnly),
TransactionMode::AccessMode(TransactionAccessMode::ReadWrite),
TransactionMode::IsolationLevel(TransactionIsolationLevel::Serializable),
]
),
_ => unreachable!(),
}
verified_stmt("START TRANSACTION");
one_statement_parses_to("BEGIN", "START TRANSACTION");
one_statement_parses_to("BEGIN WORK", "START TRANSACTION");
one_statement_parses_to("BEGIN TRANSACTION", "START TRANSACTION");
verified_stmt("START TRANSACTION ISOLATION LEVEL READ UNCOMMITTED");
verified_stmt("START TRANSACTION ISOLATION LEVEL READ COMMITTED");
verified_stmt("START TRANSACTION ISOLATION LEVEL REPEATABLE READ");
verified_stmt("START TRANSACTION ISOLATION LEVEL SERIALIZABLE");
assert_eq!(
parse_sql_statements("START TRANSACTION; SELECT 1"),
Ok(vec![
verified_stmt("START TRANSACTION"),
verified_stmt("SELECT 1"),
])
);
let res = parse_sql_statements("START TRANSACTION ISOLATION LEVEL BAD");
assert_eq!(
ParserError::ParserError("Expected isolation level, found: BAD".to_string()),
res.unwrap_err()
);
let res = parse_sql_statements("START TRANSACTION BAD");
assert_eq!(
ParserError::ParserError("Expected end of statement, found: BAD".to_string()),
res.unwrap_err()
);
let res = parse_sql_statements("START TRANSACTION READ ONLY,");
assert_eq!(
ParserError::ParserError("Expected transaction mode, found: EOF".to_string()),
res.unwrap_err()
);
}
#[test]
fn parse_set_transaction() {
match verified_stmt("SET TRANSACTION READ ONLY, READ WRITE, ISOLATION LEVEL SERIALIZABLE") {
Statement::SetTransaction(SetTransaction { modes }) => assert_eq!(
modes,
vec![
TransactionMode::AccessMode(TransactionAccessMode::ReadOnly),
TransactionMode::AccessMode(TransactionAccessMode::ReadWrite),
TransactionMode::IsolationLevel(TransactionIsolationLevel::Serializable),
]
),
_ => unreachable!(),
}
}
#[test]
fn parse_commit() {
match verified_stmt("COMMIT") {
Statement::Commit(Commit { chain: false }) => (),
_ => unreachable!(),
}
match verified_stmt("COMMIT AND CHAIN") {
Statement::Commit(Commit { chain: true }) => (),
_ => unreachable!(),
}
one_statement_parses_to("COMMIT AND NO CHAIN", "COMMIT");
one_statement_parses_to("COMMIT WORK AND NO CHAIN", "COMMIT");
one_statement_parses_to("COMMIT TRANSACTION AND NO CHAIN", "COMMIT");
one_statement_parses_to("COMMIT WORK AND CHAIN", "COMMIT AND CHAIN");
one_statement_parses_to("COMMIT TRANSACTION AND CHAIN", "COMMIT AND CHAIN");
one_statement_parses_to("COMMIT WORK", "COMMIT");
one_statement_parses_to("COMMIT TRANSACTION", "COMMIT");
}
#[test]
fn parse_rollback() {
match verified_stmt("ROLLBACK") {
Statement::Rollback(Rollback { chain: false }) => (),
_ => unreachable!(),
}
match verified_stmt("ROLLBACK AND CHAIN") {
Statement::Rollback(Rollback { chain: true }) => (),
_ => unreachable!(),
}
one_statement_parses_to("ROLLBACK AND NO CHAIN", "ROLLBACK");
one_statement_parses_to("ROLLBACK WORK AND NO CHAIN", "ROLLBACK");
one_statement_parses_to("ROLLBACK TRANSACTION AND NO CHAIN", "ROLLBACK");
one_statement_parses_to("ROLLBACK WORK AND CHAIN", "ROLLBACK AND CHAIN");
one_statement_parses_to("ROLLBACK TRANSACTION AND CHAIN", "ROLLBACK AND CHAIN");
one_statement_parses_to("ROLLBACK WORK", "ROLLBACK");
one_statement_parses_to("ROLLBACK TRANSACTION", "ROLLBACK");
}
#[test]
#[should_panic(expected = "Parse results with GenericDialect are different from PostgreSqlDialect")]
fn ensure_multiple_dialects_are_tested() {
let _ = parse_sql_statements("SELECT @foo");
}
#[test]
fn parse_create_index() {
let sql = "CREATE UNIQUE INDEX IF NOT EXISTS idx_name ON test(name,age DESC)";
let indexed_columns = vec![
OrderByExpr {
expr: Expr::Identifier(Ident::new("name")),
asc: None,
nulls_first: None,
},
OrderByExpr {
expr: Expr::Identifier(Ident::new("age")),
asc: Some(false),
nulls_first: None,
},
];
match verified_stmt(sql) {
Statement::CreateIndex(CreateIndex {
name,
table_name,
columns,
unique,
if_not_exists,
}) => {
assert_eq!("idx_name", name.to_string());
assert_eq!("test", table_name.to_string());
assert_eq!(indexed_columns, columns);
assert!(unique);
assert!(if_not_exists)
}
_ => unreachable!(),
}
}
#[test]
fn parse_drop_index() {
let sql = "DROP INDEX idx_a";
match verified_stmt(sql) {
Statement::Drop(Drop {
names, object_type, ..
}) => {
assert_eq!(
vec!["idx_a"],
names.iter().map(ToString::to_string).collect::<Vec<_>>()
);
assert_eq!(ObjectType::Index, object_type);
}
_ => unreachable!(),
}
}
#[test]
fn parse_create_table_with_json_type() {
one_statement_parses_to(
"CREATE TABLE foo (data JSON NOT NULL)",
"CREATE TABLE foo (data JSON NOT NULL)",
);
}
#[test]
fn all_keywords_sorted() {
let mut copy = Vec::from(ALL_KEYWORDS);
copy.sort_unstable();
assert_eq!(copy, ALL_KEYWORDS)
}
fn parse_sql_statements(sql: &str) -> Result<Vec<Statement>, ParserError> {
all_dialects().parse_sql_statements(sql)
}
fn one_statement_parses_to(sql: &str, canonical: &str) -> Statement {
all_dialects().one_statement_parses_to(sql, canonical)
}
fn verified_stmt(query: &str) -> Statement {
all_dialects().verified_stmt(query)
}
fn verified_query(query: &str) -> Query {
all_dialects().verified_query(query)
}
fn verified_only_select(query: &str) -> Select {
all_dialects().verified_only_select(query)
}
fn verified_expr(query: &str) -> Expr {
all_dialects().verified_expr(query)
}