mirror of
https://github.com/apache/datafusion-sqlparser-rs.git
synced 2025-08-04 06:18:17 +00:00
Reduce differences between "generic" and "postgresql" tests
Mainly by replacing `assert_eq!(sql, ast.to_string())` with a call to the recently introduced `verified()` helper or using `parses_to()` where the expected serialization differs from the original SQL string. There was one case (parse_implicit_join), where the inputs were different: let sql = "SELECT * FROM t1,t2"; //vs let sql = "SELECT * FROM t1, t2"; and since we don't test the whitespace handling in other tests, I just used the canonical representation as input.
This commit is contained in:
Nickolay Ponomarev
parent
82b1467324
commit
a1da7b4005
2 changed files with 118 additions and 149 deletions
|
|
@ -33,10 +33,8 @@ fn test_prev_index() {
|
|||
#[test]
|
||||
fn parse_delete_statement() {
|
||||
let sql: &str = "DELETE FROM 'table'";
|
||||
let ast = parse_sql(sql);
|
||||
assert_eq!("DELETE FROM 'table'", ast.to_string());
|
||||
|
||||
match parse_sql(&sql) {
|
||||
match verified(&sql) {
|
||||
ASTNode::SQLDelete { relation, .. } => {
|
||||
assert_eq!(
|
||||
Some(Box::new(ASTNode::SQLValue(Value::SingleQuotedString(
|
||||
|
|
@ -53,14 +51,11 @@ fn parse_delete_statement() {
|
|||
#[test]
|
||||
fn parse_where_delete_statement() {
|
||||
let sql: &str = "DELETE FROM 'table' WHERE name = 5";
|
||||
let ast = parse_sql(sql);
|
||||
println!("ast: {:#?}", ast);
|
||||
assert_eq!(sql, ast.to_string());
|
||||
|
||||
use self::ASTNode::*;
|
||||
use self::SQLOperator::*;
|
||||
|
||||
match parse_sql(&sql) {
|
||||
match verified(&sql) {
|
||||
ASTNode::SQLDelete {
|
||||
relation,
|
||||
selection,
|
||||
|
|
@ -77,7 +72,7 @@ fn parse_where_delete_statement() {
|
|||
SQLBinaryExpr {
|
||||
left: Box::new(SQLIdentifier("name".to_string())),
|
||||
op: Eq,
|
||||
right: Box::new(ASTNode::SQLValue(Value::Long(5))),
|
||||
right: Box::new(SQLValue(Value::Long(5))),
|
||||
},
|
||||
*selection.unwrap(),
|
||||
);
|
||||
|
|
@ -90,9 +85,7 @@ fn parse_where_delete_statement() {
|
|||
#[test]
|
||||
fn parse_simple_select() {
|
||||
let sql = String::from("SELECT id, fname, lname FROM customer WHERE id = 1 LIMIT 5");
|
||||
let ast = parse_sql(&sql);
|
||||
assert_eq!(sql, ast.to_string());
|
||||
match ast {
|
||||
match verified(&sql) {
|
||||
ASTNode::SQLSelect {
|
||||
projection, limit, ..
|
||||
} => {
|
||||
|
|
@ -234,9 +227,7 @@ fn parse_insert_invalid() {
|
|||
#[test]
|
||||
fn parse_select_wildcard() {
|
||||
let sql = String::from("SELECT * FROM customer");
|
||||
let ast = parse_sql(&sql);
|
||||
assert_eq!(sql, ast.to_string());
|
||||
match ast {
|
||||
match verified(&sql) {
|
||||
ASTNode::SQLSelect { projection, .. } => {
|
||||
assert_eq!(1, projection.len());
|
||||
assert_eq!(ASTNode::SQLWildcard, projection[0]);
|
||||
|
|
@ -248,9 +239,7 @@ fn parse_select_wildcard() {
|
|||
#[test]
|
||||
fn parse_select_count_wildcard() {
|
||||
let sql = String::from("SELECT COUNT(*) FROM customer");
|
||||
let ast = parse_sql(&sql);
|
||||
assert_eq!(sql, ast.to_string());
|
||||
match ast {
|
||||
match verified(&sql) {
|
||||
ASTNode::SQLSelect { projection, .. } => {
|
||||
assert_eq!(1, projection.len());
|
||||
assert_eq!(
|
||||
|
|
@ -271,15 +260,15 @@ fn parse_select_string_predicate() {
|
|||
"SELECT id, fname, lname FROM customer \
|
||||
WHERE salary != 'Not Provided' AND salary != ''",
|
||||
);
|
||||
let ast = parse_sql(&sql);
|
||||
assert_eq!(sql, ast.to_string());
|
||||
let _ast = verified(&sql);
|
||||
//TODO: add assertions
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_projection_nested_type() {
|
||||
let sql = String::from("SELECT customer.address.state FROM foo");
|
||||
let ast = parse_sql(&sql);
|
||||
assert_eq!(sql, ast.to_string());
|
||||
let _ast = verified(&sql);
|
||||
//TODO: add assertions
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -287,8 +276,6 @@ fn parse_compound_expr_1() {
|
|||
use self::ASTNode::*;
|
||||
use self::SQLOperator::*;
|
||||
let sql = String::from("a + b * c");
|
||||
let ast = parse_sql(&sql);
|
||||
assert_eq!(sql, ast.to_string());
|
||||
assert_eq!(
|
||||
SQLBinaryExpr {
|
||||
left: Box::new(SQLIdentifier("a".to_string())),
|
||||
|
|
@ -299,7 +286,7 @@ fn parse_compound_expr_1() {
|
|||
right: Box::new(SQLIdentifier("c".to_string()))
|
||||
})
|
||||
},
|
||||
ast
|
||||
verified(&sql)
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -308,8 +295,6 @@ fn parse_compound_expr_2() {
|
|||
use self::ASTNode::*;
|
||||
use self::SQLOperator::*;
|
||||
let sql = String::from("a * b + c");
|
||||
let ast = parse_sql(&sql);
|
||||
assert_eq!(sql, ast.to_string());
|
||||
assert_eq!(
|
||||
SQLBinaryExpr {
|
||||
left: Box::new(SQLBinaryExpr {
|
||||
|
|
@ -320,7 +305,7 @@ fn parse_compound_expr_2() {
|
|||
op: Plus,
|
||||
right: Box::new(SQLIdentifier("c".to_string()))
|
||||
},
|
||||
ast
|
||||
verified(&sql)
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -328,18 +313,20 @@ fn parse_compound_expr_2() {
|
|||
fn parse_is_null() {
|
||||
use self::ASTNode::*;
|
||||
let sql = String::from("a IS NULL");
|
||||
let ast = parse_sql(&sql);
|
||||
assert_eq!(sql, ast.to_string());
|
||||
assert_eq!(SQLIsNull(Box::new(SQLIdentifier("a".to_string()))), ast);
|
||||
assert_eq!(
|
||||
SQLIsNull(Box::new(SQLIdentifier("a".to_string()))),
|
||||
verified(&sql)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_is_not_null() {
|
||||
use self::ASTNode::*;
|
||||
let sql = String::from("a IS NOT NULL");
|
||||
let ast = parse_sql(&sql);
|
||||
assert_eq!(sql, ast.to_string());
|
||||
assert_eq!(SQLIsNotNull(Box::new(SQLIdentifier("a".to_string()))), ast);
|
||||
assert_eq!(
|
||||
SQLIsNotNull(Box::new(SQLIdentifier("a".to_string()))),
|
||||
verified(&sql)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -347,9 +334,7 @@ fn parse_select_order_by() {
|
|||
let sql = String::from(
|
||||
"SELECT id, fname, lname FROM customer WHERE id < 5 ORDER BY lname ASC, fname DESC",
|
||||
);
|
||||
let ast = parse_sql(&sql);
|
||||
assert_eq!(sql, ast.to_string());
|
||||
match ast {
|
||||
match verified(&sql) {
|
||||
ASTNode::SQLSelect { order_by, .. } => {
|
||||
assert_eq!(
|
||||
Some(vec![
|
||||
|
|
@ -372,9 +357,7 @@ fn parse_select_order_by() {
|
|||
#[test]
|
||||
fn parse_select_group_by() {
|
||||
let sql = String::from("SELECT id, fname, lname FROM customer GROUP BY lname, fname");
|
||||
let ast = parse_sql(&sql);
|
||||
assert_eq!(sql, ast.to_string());
|
||||
match ast {
|
||||
match verified(&sql) {
|
||||
ASTNode::SQLSelect { group_by, .. } => {
|
||||
assert_eq!(
|
||||
Some(vec![
|
||||
|
|
@ -390,27 +373,16 @@ fn parse_select_group_by() {
|
|||
|
||||
#[test]
|
||||
fn parse_limit_accepts_all() {
|
||||
let sql = String::from("SELECT id, fname, lname FROM customer WHERE id = 1 LIMIT ALL");
|
||||
let expected = String::from("SELECT id, fname, lname FROM customer WHERE id = 1");
|
||||
let ast = parse_sql(&sql);
|
||||
assert_eq!(expected, ast.to_string());
|
||||
match ast {
|
||||
ASTNode::SQLSelect {
|
||||
projection, limit, ..
|
||||
} => {
|
||||
assert_eq!(3, projection.len());
|
||||
assert_eq!(None, limit);
|
||||
}
|
||||
_ => assert!(false),
|
||||
}
|
||||
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 = String::from("SELECT CAST(id AS bigint) FROM customer");
|
||||
let ast = parse_sql(&sql);
|
||||
assert_eq!(sql, ast.to_string());
|
||||
match ast {
|
||||
match verified(&sql) {
|
||||
ASTNode::SQLSelect { projection, .. } => {
|
||||
assert_eq!(1, projection.len());
|
||||
assert_eq!(
|
||||
|
|
@ -423,6 +395,10 @@ fn parse_cast() {
|
|||
}
|
||||
_ => assert!(false),
|
||||
}
|
||||
parses_to(
|
||||
"SELECT CAST(id AS BIGINT) FROM customer",
|
||||
"SELECT CAST(id AS bigint) FROM customer",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -433,15 +409,14 @@ fn parse_create_table() {
|
|||
lat DOUBLE NULL,\
|
||||
lng DOUBLE NULL)",
|
||||
);
|
||||
let expected = String::from(
|
||||
parses_to(
|
||||
&sql,
|
||||
"CREATE TABLE uk_cities (\
|
||||
name character varying(100) NOT NULL, \
|
||||
lat double, \
|
||||
lng double)",
|
||||
);
|
||||
let ast = parse_sql(&sql);
|
||||
assert_eq!(expected, ast.to_string());
|
||||
match ast {
|
||||
match parse_sql(&sql) {
|
||||
ASTNode::SQLCreateTable { name, columns } => {
|
||||
assert_eq!("uk_cities", name);
|
||||
assert_eq!(3, columns.len());
|
||||
|
|
@ -688,34 +663,31 @@ fn parse_example_value() {
|
|||
#[test]
|
||||
fn parse_scalar_function_in_projection() {
|
||||
let sql = String::from("SELECT sqrt(id) FROM foo");
|
||||
let ast = parse_sql(&sql);
|
||||
assert_eq!(sql, ast.to_string());
|
||||
if let ASTNode::SQLSelect { projection, .. } = ast {
|
||||
assert_eq!(
|
||||
vec![ASTNode::SQLFunction {
|
||||
id: String::from("sqrt"),
|
||||
args: vec![ASTNode::SQLIdentifier(String::from("id"))],
|
||||
}],
|
||||
projection
|
||||
);
|
||||
} else {
|
||||
assert!(false);
|
||||
match verified(&sql) {
|
||||
ASTNode::SQLSelect { projection, .. } => {
|
||||
assert_eq!(
|
||||
vec![ASTNode::SQLFunction {
|
||||
id: String::from("sqrt"),
|
||||
args: vec![ASTNode::SQLIdentifier(String::from("id"))],
|
||||
}],
|
||||
projection
|
||||
);
|
||||
}
|
||||
_ => assert!(false),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_aggregate_with_group_by() {
|
||||
let sql = String::from("SELECT a, COUNT(1), MIN(b), MAX(b) FROM foo GROUP BY a");
|
||||
let ast = parse_sql(&sql);
|
||||
assert_eq!(sql, ast.to_string());
|
||||
let _ast = verified(&sql);
|
||||
//TODO: assertions
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_literal_string() {
|
||||
let sql = "SELECT 'one'";
|
||||
let ast = parse_sql(&sql);
|
||||
assert_eq!(sql, ast.to_string());
|
||||
match ast {
|
||||
match verified(&sql) {
|
||||
ASTNode::SQLSelect { ref projection, .. } => {
|
||||
assert_eq!(
|
||||
projection[0],
|
||||
|
|
@ -729,9 +701,7 @@ fn parse_literal_string() {
|
|||
#[test]
|
||||
fn parse_select_version() {
|
||||
let sql = "SELECT @@version";
|
||||
let ast = parse_sql(&sql);
|
||||
assert_eq!(sql, ast.to_string());
|
||||
match ast {
|
||||
match verified(&sql) {
|
||||
ASTNode::SQLSelect { ref projection, .. } => {
|
||||
assert_eq!(
|
||||
projection[0],
|
||||
|
|
@ -851,11 +821,13 @@ fn parse_joins_using() {
|
|||
}
|
||||
|
||||
#[test]
|
||||
fn parse_join_syntax_variants() {
|
||||
fn parses_to(from: &str, to: &str) {
|
||||
assert_eq!(to, &parse_sql(from).to_string())
|
||||
}
|
||||
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";
|
||||
assert_eq!(sql, parse_sql(sql).to_string());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_join_syntax_variants() {
|
||||
parses_to(
|
||||
"SELECT c1 FROM t1 INNER JOIN t2 USING(c1)",
|
||||
"SELECT c1 FROM t1 JOIN t2 USING(c1)",
|
||||
|
|
@ -874,18 +846,16 @@ fn parse_join_syntax_variants() {
|
|||
);
|
||||
}
|
||||
|
||||
#[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";
|
||||
assert_eq!(sql, parse_sql(sql).to_string());
|
||||
}
|
||||
|
||||
fn verified(query: &str) -> ASTNode {
|
||||
let ast = parse_sql(query);
|
||||
assert_eq!(query, &ast.to_string());
|
||||
ast
|
||||
}
|
||||
|
||||
fn parses_to(from: &str, to: &str) {
|
||||
assert_eq!(to, &parse_sql(from).to_string())
|
||||
}
|
||||
|
||||
fn joins_from(ast: ASTNode) -> Vec<Join> {
|
||||
match ast {
|
||||
ASTNode::SQLSelect { joins, .. } => joins,
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue