Merge pull request #38 from nickolay/remove-duplicate-tests

Remove sqlparser_generic.rs/sqlparser_postgres.rs duplication

tests/sqlparser_generic.rs

@@ -1,7 +1,7 @@
 extern crate log;
 extern crate sqlparser;
 
-use sqlparser::dialect::GenericSqlDialect;
+use sqlparser::dialect::*;
 use sqlparser::sqlast::*;
 use sqlparser::sqlparser::*;
 use sqlparser::sqltokenizer::*;
@@ -10,7 +10,7 @@ use sqlparser::sqltokenizer::*;
 fn parse_delete_statement() {
     let sql: &str = "DELETE FROM 'table'";
 
-    match parse_sql(&sql) {
+    match verified(&sql) {
         ASTNode::SQLDelete { relation, .. } => {
             assert_eq!(
                 Some(Box::new(ASTNode::SQLValue(Value::SingleQuotedString(
@@ -31,7 +31,7 @@ fn parse_where_delete_statement() {
     use self::ASTNode::*;
     use self::SQLOperator::*;
 
-    match parse_sql(&sql) {
+    match verified(&sql) {
         ASTNode::SQLDelete {
             relation,
             selection,
@@ -61,8 +61,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);
+    match verified(&sql) {
-    match ast {
         ASTNode::SQLSelect {
             projection, limit, ..
         } => {
@@ -76,8 +75,7 @@ fn parse_simple_select() {
 #[test]
 fn parse_select_wildcard() {
     let sql = String::from("SELECT * FROM customer");
-    let ast = parse_sql(&sql);
+    match verified(&sql) {
-    match ast {
         ASTNode::SQLSelect { projection, .. } => {
             assert_eq!(1, projection.len());
             assert_eq!(ASTNode::SQLWildcard, projection[0]);
@@ -89,8 +87,7 @@ fn parse_select_wildcard() {
 #[test]
 fn parse_select_count_wildcard() {
     let sql = String::from("SELECT COUNT(*) FROM customer");
-    let ast = parse_sql(&sql);
+    match verified(&sql) {
-    match ast {
         ASTNode::SQLSelect { projection, .. } => {
             assert_eq!(1, projection.len());
             assert_eq!(
@@ -111,7 +108,7 @@ fn parse_not() {
         "SELECT id FROM customer \
          WHERE NOT salary = ''",
     );
-    let _ast = parse_sql(&sql);
+    let _ast = verified(&sql);
     //TODO: add assertions
 }
 
@@ -121,14 +118,14 @@ fn parse_select_string_predicate() {
         "SELECT id, fname, lname FROM customer \
          WHERE salary != 'Not Provided' AND salary != ''",
     );
-    let _ast = parse_sql(&sql);
+    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);
+    let _ast = verified(&sql);
     //TODO: add assertions
 }
 
@@ -137,7 +134,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!(
         SQLBinaryExpr {
             left: Box::new(SQLIdentifier("a".to_string())),
@@ -148,7 +144,7 @@ fn parse_compound_expr_1() {
                 right: Box::new(SQLIdentifier("c".to_string()))
             })
         },
-        ast
+        verified(&sql)
     );
 }
 
@@ -157,7 +153,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!(
         SQLBinaryExpr {
             left: Box::new(SQLBinaryExpr {
@@ -168,7 +163,7 @@ fn parse_compound_expr_2() {
             op: Plus,
             right: Box::new(SQLIdentifier("c".to_string()))
         },
-        ast
+        verified(&sql)
     );
 }
 
@@ -176,16 +171,60 @@ 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!(
-    assert_eq!(SQLIsNull(Box::new(SQLIdentifier("a".to_string()))), ast);
+        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!(
-    assert_eq!(SQLIsNotNull(Box::new(SQLIdentifier("a".to_string()))), ast);
+        SQLIsNotNull(Box::new(SQLIdentifier("a".to_string()))),
+        verified(&sql)
+    );
+}
+
+#[test]
+fn parse_like() {
+    let sql = String::from("SELECT * FROM customers WHERE name LIKE '%a'");
+    match verified(&sql) {
+        ASTNode::SQLSelect { selection, .. } => {
+            assert_eq!(
+                ASTNode::SQLBinaryExpr {
+                    left: Box::new(ASTNode::SQLIdentifier("name".to_string())),
+                    op: SQLOperator::Like,
+                    right: Box::new(ASTNode::SQLValue(Value::SingleQuotedString(
+                        "%a".to_string()
+                    ))),
+                },
+                *selection.unwrap()
+            );
+        }
+        _ => assert!(false),
+    }
+}
+
+#[test]
+fn parse_not_like() {
+    let sql = String::from("SELECT * FROM customers WHERE name NOT LIKE '%a'");
+    match verified(&sql) {
+        ASTNode::SQLSelect { selection, .. } => {
+            assert_eq!(
+                ASTNode::SQLBinaryExpr {
+                    left: Box::new(ASTNode::SQLIdentifier("name".to_string())),
+                    op: SQLOperator::NotLike,
+                    right: Box::new(ASTNode::SQLValue(Value::SingleQuotedString(
+                        "%a".to_string()
+                    ))),
+                },
+                *selection.unwrap()
+            );
+        }
+        _ => assert!(false),
+    }
 }
 
 #[test]
@@ -193,8 +232,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);
+    match verified(&sql) {
-    match ast {
         ASTNode::SQLSelect { order_by, .. } => {
             assert_eq!(
                 Some(vec![
@@ -246,8 +284,7 @@ fn parse_select_order_by_limit() {
 #[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);
+    match verified(&sql) {
-    match ast {
         ASTNode::SQLSelect { group_by, .. } => {
             assert_eq!(
                 Some(vec![
@@ -263,24 +300,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");
+    parses_to(
-    let ast = parse_sql(&sql);
+        "SELECT id, fname, lname FROM customer WHERE id = 1 LIMIT ALL",
-    match ast {
+        "SELECT id, fname, lname FROM customer WHERE id = 1",
-        ASTNode::SQLSelect {
+    );
-            projection, limit, ..
-        } => {
-            assert_eq!(3, projection.len());
-            assert_eq!(None, limit);
-        }
-        _ => assert!(false),
-    }
 }
 
 #[test]
 fn parse_cast() {
-    let sql = String::from("SELECT CAST(id AS BIGINT) FROM customer");
+    let sql = String::from("SELECT CAST(id AS bigint) FROM customer");
-    let ast = parse_sql(&sql);
+    match verified(&sql) {
-    match ast {
         ASTNode::SQLSelect { projection, .. } => {
             assert_eq!(1, projection.len());
             assert_eq!(
@@ -293,6 +322,10 @@ fn parse_cast() {
         }
         _ => assert!(false),
     }
+    parses_to(
+        "SELECT CAST(id AS BIGINT) FROM customer",
+        "SELECT CAST(id AS bigint) FROM customer",
+    );
 }
 
 #[test]
@@ -303,8 +336,14 @@ fn parse_create_table() {
          lat DOUBLE NULL,\
          lng DOUBLE NULL)",
     );
-    let ast = parse_sql(&sql);
+    parses_to(
-    match ast {
+        &sql,
+        "CREATE TABLE uk_cities (\
+         name character varying(100) NOT NULL, \
+         lat double, \
+         lng double)",
+    );
+    match parse_sql(&sql) {
         ASTNode::SQLCreateTable { name, columns } => {
             assert_eq!("uk_cities", name);
             assert_eq!(3, columns.len());
@@ -331,8 +370,8 @@ fn parse_create_table() {
 #[test]
 fn parse_scalar_function_in_projection() {
     let sql = String::from("SELECT sqrt(id) FROM foo");
-    let ast = parse_sql(&sql);
+    match verified(&sql) {
-    if let ASTNode::SQLSelect { projection, .. } = ast {
+        ASTNode::SQLSelect { projection, .. } => {
             assert_eq!(
                 vec![ASTNode::SQLFunction {
                     id: String::from("sqrt"),
@@ -340,22 +379,22 @@ fn parse_scalar_function_in_projection() {
                 }],
                 projection
             );
-    } else {
+        }
-        assert!(false);
+        _ => 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);
+    let _ast = verified(&sql);
     //TODO: assertions
 }
 
 #[test]
 fn parse_literal_string() {
     let sql = "SELECT 'one'";
-    match parse_sql(&sql) {
+    match verified(&sql) {
         ASTNode::SQLSelect { ref projection, .. } => {
             assert_eq!(
                 projection[0],
@@ -381,7 +420,7 @@ fn parse_simple_math_expr_minus() {
 #[test]
 fn parse_select_version() {
     let sql = "SELECT @@version";
-    match parse_sql(&sql) {
+    match verified(&sql) {
         ASTNode::SQLSelect { ref projection, .. } => {
             assert_eq!(
                 projection[0],
@@ -490,7 +529,7 @@ fn parse_delete_with_semi_colon() {
 fn parse_implicit_join() {
     let sql = "SELECT * FROM t1, t2";
 
-    match parse_sql(sql) {
+    match verified(sql) {
         ASTNode::SQLSelect { joins, .. } => {
             assert_eq!(joins.len(), 1);
             assert_eq!(
@@ -509,7 +548,7 @@ fn parse_implicit_join() {
 fn parse_cross_join() {
     let sql = "SELECT * FROM t1 CROSS JOIN t2";
 
-    match parse_sql(sql) {
+    match verified(sql) {
         ASTNode::SQLSelect { joins, .. } => {
             assert_eq!(joins.len(), 1);
             assert_eq!(
@@ -595,10 +634,6 @@ fn parse_complex_join() {
 
 #[test]
 fn parse_join_syntax_variants() {
-    fn parses_to(from: &str, to: &str) {
-        assert_eq!(to, &parse_sql(from).to_string())
-    }
-
     parses_to(
         "SELECT c1 FROM t1 INNER JOIN t2 USING(c1)",
         "SELECT c1 FROM t1 JOIN t2 USING(c1)",
@@ -623,6 +658,10 @@ fn verified(query: &str) -> ASTNode {
     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,
@@ -631,8 +670,14 @@ fn joins_from(ast: ASTNode) -> Vec<Join> {
 }
 
 fn parse_sql(sql: &str) -> ASTNode {
-    let dialect = GenericSqlDialect {};
+    let generic_ast = parse_sql_with(sql, &GenericSqlDialect {});
-    let mut tokenizer = Tokenizer::new(&dialect, &sql);
+    let pg_ast = parse_sql_with(sql, &PostgreSqlDialect {});
+    assert_eq!(generic_ast, pg_ast);
+    generic_ast
+}
+
+fn parse_sql_with(sql: &str, dialect: &Dialect) -> ASTNode {
+    let mut tokenizer = Tokenizer::new(dialect, &sql);
     let tokens = tokenizer.tokenize().unwrap();
     let mut parser = Parser::new(tokens);
     let ast = parser.parse().unwrap();

tests/sqlparser_postgres.rs

@@ -30,85 +30,10 @@ fn test_prev_index() {
     assert_eq!(parser.prev_token(), None);
 }
 
-#[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) {
-        ASTNode::SQLDelete { relation, .. } => {
-            assert_eq!(
-                Some(Box::new(ASTNode::SQLValue(Value::SingleQuotedString(
-                    "table".to_string()
-                )))),
-                relation
-            );
-        }
-
-        _ => assert!(false),
-    }
-}
-
-#[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) {
-        ASTNode::SQLDelete {
-            relation,
-            selection,
-            ..
-        } => {
-            assert_eq!(
-                Some(Box::new(ASTNode::SQLValue(Value::SingleQuotedString(
-                    "table".to_string()
-                )))),
-                relation
-            );
-
-            assert_eq!(
-                SQLBinaryExpr {
-                    left: Box::new(SQLIdentifier("name".to_string())),
-                    op: Eq,
-                    right: Box::new(ASTNode::SQLValue(Value::Long(5))),
-                },
-                *selection.unwrap(),
-            );
-        }
-
-        _ => assert!(false),
-    }
-}
-
-#[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 {
-        ASTNode::SQLSelect {
-            projection, limit, ..
-        } => {
-            assert_eq!(3, projection.len());
-            assert_eq!(Some(Box::new(ASTNode::SQLValue(Value::Long(5)))), limit);
-        }
-        _ => assert!(false),
-    }
-}
-
 #[test]
 fn parse_simple_insert() {
     let sql = String::from("INSERT INTO customer VALUES(1, 2, 3)");
-    let ast = parse_sql(&sql);
+    match verified(&sql) {
-    assert_eq!(sql, ast.to_string());
-    match ast {
         ASTNode::SQLInsert {
             table_name,
             columns,
@@ -133,9 +58,7 @@ fn parse_simple_insert() {
 #[test]
 fn parse_common_insert() {
     let sql = String::from("INSERT INTO public.customer VALUES(1, 2, 3)");
-    let ast = parse_sql(&sql);
+    match verified(&sql) {
-    assert_eq!(sql, ast.to_string());
-    match ast {
         ASTNode::SQLInsert {
             table_name,
             columns,
@@ -160,9 +83,7 @@ fn parse_common_insert() {
 #[test]
 fn parse_complex_insert() {
     let sql = String::from("INSERT INTO db.public.customer VALUES(1, 2, 3)");
-    let ast = parse_sql(&sql);
+    match verified(&sql) {
-    assert_eq!(sql, ast.to_string());
-    match ast {
         ASTNode::SQLInsert {
             table_name,
             columns,
@@ -194,9 +115,7 @@ fn parse_invalid_table_name() {
 #[test]
 fn parse_insert_with_columns() {
     let sql = String::from("INSERT INTO public.customer (id, name, active) VALUES(1, 2, 3)");
-    let ast = parse_sql(&sql);
+    match verified(&sql) {
-    assert_eq!(sql, ast.to_string());
-    match ast {
         ASTNode::SQLInsert {
             table_name,
             columns,
@@ -231,240 +150,6 @@ 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 {
-        ASTNode::SQLSelect { projection, .. } => {
-            assert_eq!(1, projection.len());
-            assert_eq!(ASTNode::SQLWildcard, projection[0]);
-        }
-        _ => assert!(false),
-    }
-}
-
-#[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 {
-        ASTNode::SQLSelect { projection, .. } => {
-            assert_eq!(1, projection.len());
-            assert_eq!(
-                ASTNode::SQLFunction {
-                    id: "COUNT".to_string(),
-                    args: vec![ASTNode::SQLWildcard],
-                },
-                projection[0]
-            );
-        }
-        _ => assert!(false),
-    }
-}
-
-#[test]
-fn parse_select_string_predicate() {
-    let sql = String::from(
-        "SELECT id, fname, lname FROM customer \
-         WHERE salary != 'Not Provided' AND salary != ''",
-    );
-    let ast = parse_sql(&sql);
-    assert_eq!(sql, ast.to_string());
-}
-
-#[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());
-}
-
-#[test]
-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())),
-            op: Plus,
-            right: Box::new(SQLBinaryExpr {
-                left: Box::new(SQLIdentifier("b".to_string())),
-                op: Multiply,
-                right: Box::new(SQLIdentifier("c".to_string()))
-            })
-        },
-        ast
-    );
-}
-
-#[test]
-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 {
-                left: Box::new(SQLIdentifier("a".to_string())),
-                op: Multiply,
-                right: Box::new(SQLIdentifier("b".to_string()))
-            }),
-            op: Plus,
-            right: Box::new(SQLIdentifier("c".to_string()))
-        },
-        ast
-    );
-}
-
-#[test]
-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);
-}
-
-#[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);
-}
-
-#[test]
-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 {
-        ASTNode::SQLSelect { order_by, .. } => {
-            assert_eq!(
-                Some(vec![
-                    SQLOrderByExpr {
-                        expr: Box::new(ASTNode::SQLIdentifier("lname".to_string())),
-                        asc: true,
-                    },
-                    SQLOrderByExpr {
-                        expr: Box::new(ASTNode::SQLIdentifier("fname".to_string())),
-                        asc: false,
-                    },
-                ]),
-                order_by
-            );
-        }
-        _ => assert!(false),
-    }
-}
-
-#[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 {
-        ASTNode::SQLSelect { group_by, .. } => {
-            assert_eq!(
-                Some(vec![
-                    ASTNode::SQLIdentifier("lname".to_string()),
-                    ASTNode::SQLIdentifier("fname".to_string()),
-                ]),
-                group_by
-            );
-        }
-        _ => assert!(false),
-    }
-}
-
-#[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),
-    }
-}
-
-#[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 {
-        ASTNode::SQLSelect { projection, .. } => {
-            assert_eq!(1, projection.len());
-            assert_eq!(
-                ASTNode::SQLCast {
-                    expr: Box::new(ASTNode::SQLIdentifier("id".to_string())),
-                    data_type: SQLType::BigInt
-                },
-                projection[0]
-            );
-        }
-        _ => assert!(false),
-    }
-}
-
-#[test]
-fn parse_create_table() {
-    let sql = String::from(
-        "CREATE TABLE uk_cities (\
-         name VARCHAR(100) NOT NULL,\
-         lat DOUBLE NULL,\
-         lng DOUBLE NULL)",
-    );
-    let expected = String::from(
-        "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 {
-        ASTNode::SQLCreateTable { name, columns } => {
-            assert_eq!("uk_cities", name);
-            assert_eq!(3, columns.len());
-
-            let c_name = &columns[0];
-            assert_eq!("name", c_name.name);
-            assert_eq!(SQLType::Varchar(Some(100)), c_name.data_type);
-            assert_eq!(false, c_name.allow_null);
-
-            let c_lat = &columns[1];
-            assert_eq!("lat", c_lat.name);
-            assert_eq!(SQLType::Double, c_lat.data_type);
-            assert_eq!(true, c_lat.allow_null);
-
-            let c_lng = &columns[2];
-            assert_eq!("lng", c_lng.name);
-            assert_eq!(SQLType::Double, c_lng.data_type);
-            assert_eq!(true, c_lng.allow_null);
-        }
-        _ => assert!(false),
-    }
-}
-
 #[test]
 fn parse_create_table_with_defaults() {
     let sql = String::from(
@@ -480,8 +165,7 @@ fn parse_create_table_with_defaults() {
             last_update timestamp without time zone DEFAULT now() NOT NULL,
             active integer NOT NULL)",
     );
-    let ast = parse_sql(&sql);
+    match parse_sql(&sql) {
-    match ast {
         ASTNode::SQLCreateTable { name, columns } => {
             assert_eq!("public.customer", name);
             assert_eq!(10, columns.len());
@@ -577,9 +261,7 @@ fn parse_create_table_with_inherit() {
          use_metric boolean DEFAULT true\
          )",
     );
-    let ast = parse_sql(&sql);
+    match verified(&sql) {
-    assert_eq!(sql, ast.to_string());
-    match ast {
         ASTNode::SQLCreateTable { name, columns } => {
             assert_eq!("bazaar.settings", name);
 
@@ -608,10 +290,7 @@ fn parse_alter_table_constraint_primary_key() {
          ALTER TABLE bazaar.address \
          ADD CONSTRAINT address_pkey PRIMARY KEY (address_id)",
     );
-    let ast = parse_sql(&sql);
+    match verified(&sql) {
-    println!("ast: {:?}", ast);
-    assert_eq!(sql, ast.to_string());
-    match ast {
         ASTNode::SQLAlterTable { name, .. } => {
             assert_eq!(name, "bazaar.address");
         }
@@ -624,10 +303,7 @@ fn parse_alter_table_constraint_foreign_key() {
     let sql = String::from("\
     ALTER TABLE public.customer \
         ADD CONSTRAINT customer_address_id_fkey FOREIGN KEY (address_id) REFERENCES public.address(address_id)");
-    let ast = parse_sql(&sql);
+    match verified(&sql) {
-    assert_eq!(sql, ast.to_string());
-    println!("ast: {:?}", ast);
-    match ast {
         ASTNode::SQLAlterTable { name, .. } => {
             assert_eq!(name, "public.customer");
         }
@@ -685,63 +361,6 @@ fn parse_example_value() {
     assert_eq!(sql, ast.to_string());
 }
 
-#[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);
-    }
-}
-
-#[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());
-}
-
-#[test]
-fn parse_literal_string() {
-    let sql = "SELECT 'one'";
-    let ast = parse_sql(&sql);
-    assert_eq!(sql, ast.to_string());
-    match ast {
-        ASTNode::SQLSelect { ref projection, .. } => {
-            assert_eq!(
-                projection[0],
-                ASTNode::SQLValue(Value::SingleQuotedString("one".to_string()))
-            );
-        }
-        _ => panic!(),
-    }
-}
-
-#[test]
-fn parse_select_version() {
-    let sql = "SELECT @@version";
-    let ast = parse_sql(&sql);
-    assert_eq!(sql, ast.to_string());
-    match ast {
-        ASTNode::SQLSelect { ref projection, .. } => {
-            assert_eq!(
-                projection[0],
-                ASTNode::SQLIdentifier("@@version".to_string())
-            );
-        }
-        _ => panic!(),
-    }
-}
-
 #[test]
 fn parse_function_now() {
     let sql = "now()";
@@ -749,150 +368,12 @@ fn parse_function_now() {
     assert_eq!(sql, ast.to_string());
 }
 
-#[test]
-fn parse_implicit_join() {
-    let sql = "SELECT * FROM t1, t2";
-
-    match verified(sql) {
-        ASTNode::SQLSelect { joins, .. } => {
-            assert_eq!(joins.len(), 1);
-            assert_eq!(
-                joins[0],
-                Join {
-                    relation: ASTNode::SQLIdentifier("t2".to_string()),
-                    join_operator: JoinOperator::Implicit
-                }
-            )
-        }
-        _ => assert!(false),
-    }
-}
-
-#[test]
-fn parse_cross_join() {
-    let sql = "SELECT * FROM t1 CROSS JOIN t2";
-
-    match verified(sql) {
-        ASTNode::SQLSelect { joins, .. } => {
-            assert_eq!(joins.len(), 1);
-            assert_eq!(
-                joins[0],
-                Join {
-                    relation: ASTNode::SQLIdentifier("t2".to_string()),
-                    join_operator: JoinOperator::Cross
-                }
-            )
-        }
-        _ => assert!(false),
-    }
-}
-
-#[test]
-fn parse_joins_on() {
-    fn join_with_constraint(
-        relation: impl Into<String>,
-        f: impl Fn(JoinConstraint) -> JoinOperator,
-    ) -> Join {
-        Join {
-            relation: ASTNode::SQLIdentifier(relation.into()),
-            join_operator: f(JoinConstraint::On(ASTNode::SQLBinaryExpr {
-                left: Box::new(ASTNode::SQLIdentifier("c1".into())),
-                op: SQLOperator::Eq,
-                right: Box::new(ASTNode::SQLIdentifier("c2".into())),
-            })),
-        }
-    }
-    assert_eq!(
-        joins_from(verified("SELECT * FROM t1 JOIN t2 ON c1 = c2")),
-        vec![join_with_constraint("t2", JoinOperator::Inner)]
-    );
-    assert_eq!(
-        joins_from(verified("SELECT * FROM t1 LEFT JOIN t2 ON c1 = c2")),
-        vec![join_with_constraint("t2", JoinOperator::LeftOuter)]
-    );
-    assert_eq!(
-        joins_from(verified("SELECT * FROM t1 RIGHT JOIN t2 ON c1 = c2")),
-        vec![join_with_constraint("t2", JoinOperator::RightOuter)]
-    );
-    assert_eq!(
-        joins_from(verified("SELECT * FROM t1 FULL JOIN t2 ON c1 = c2")),
-        vec![join_with_constraint("t2", JoinOperator::FullOuter)]
-    );
-}
-
-#[test]
-fn parse_joins_using() {
-    fn join_with_constraint(
-        relation: impl Into<String>,
-        f: impl Fn(JoinConstraint) -> JoinOperator,
-    ) -> Join {
-        Join {
-            relation: ASTNode::SQLIdentifier(relation.into()),
-            join_operator: f(JoinConstraint::Using(vec!["c1".into()])),
-        }
-    }
-
-    assert_eq!(
-        joins_from(verified("SELECT * FROM t1 JOIN t2 USING(c1)")),
-        vec![join_with_constraint("t2", JoinOperator::Inner)]
-    );
-    assert_eq!(
-        joins_from(verified("SELECT * FROM t1 LEFT JOIN t2 USING(c1)")),
-        vec![join_with_constraint("t2", JoinOperator::LeftOuter)]
-    );
-    assert_eq!(
-        joins_from(verified("SELECT * FROM t1 RIGHT JOIN t2 USING(c1)")),
-        vec![join_with_constraint("t2", JoinOperator::RightOuter)]
-    );
-    assert_eq!(
-        joins_from(verified("SELECT * FROM t1 FULL JOIN t2 USING(c1)")),
-        vec![join_with_constraint("t2", JoinOperator::FullOuter)]
-    );
-}
-
-#[test]
-fn parse_join_syntax_variants() {
-    fn parses_to(from: &str, to: &str) {
-        assert_eq!(to, &parse_sql(from).to_string())
-    }
-
-    parses_to(
-        "SELECT c1 FROM t1 INNER JOIN t2 USING(c1)",
-        "SELECT c1 FROM t1 JOIN t2 USING(c1)",
-    );
-    parses_to(
-        "SELECT c1 FROM t1 LEFT OUTER JOIN t2 USING(c1)",
-        "SELECT c1 FROM t1 LEFT JOIN t2 USING(c1)",
-    );
-    parses_to(
-        "SELECT c1 FROM t1 RIGHT OUTER JOIN t2 USING(c1)",
-        "SELECT c1 FROM t1 RIGHT JOIN t2 USING(c1)",
-    );
-    parses_to(
-        "SELECT c1 FROM t1 FULL OUTER JOIN t2 USING(c1)",
-        "SELECT c1 FROM t1 FULL JOIN t2 USING(c1)",
-    );
-}
-
-#[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 joins_from(ast: ASTNode) -> Vec<Join> {
-    match ast {
-        ASTNode::SQLSelect { joins, .. } => joins,
-        _ => panic!("Expected SELECT"),
-    }
-}
-
 fn parse_sql(sql: &str) -> ASTNode {
     debug!("sql: {}", sql);
     let mut parser = parser(sql);
@@ -907,47 +388,3 @@ fn parser(sql: &str) -> Parser {
     debug!("tokens: {:#?}", tokens);
     Parser::new(tokens)
 }
-
-#[test]
-fn parse_like() {
-    let sql = String::from("SELECT * FROM customers WHERE name LIKE '%a'");
-    let ast = parse_sql(&sql);
-    assert_eq!(sql, ast.to_string());
-    match ast {
-        ASTNode::SQLSelect { selection, .. } => {
-            assert_eq!(
-                ASTNode::SQLBinaryExpr {
-                    left: Box::new(ASTNode::SQLIdentifier("name".to_string())),
-                    op: SQLOperator::Like,
-                    right: Box::new(ASTNode::SQLValue(Value::SingleQuotedString(
-                        "%a".to_string()
-                    ))),
-                },
-                *selection.unwrap()
-            );
-        }
-        _ => assert!(false),
-    }
-}
-
-#[test]
-fn parse_not_like() {
-    let sql = String::from("SELECT * FROM customers WHERE name NOT LIKE '%a'");
-    let ast = parse_sql(&sql);
-    assert_eq!(sql, ast.to_string());
-    match ast {
-        ASTNode::SQLSelect { selection, .. } => {
-            assert_eq!(
-                ASTNode::SQLBinaryExpr {
-                    left: Box::new(ASTNode::SQLIdentifier("name".to_string())),
-                    op: SQLOperator::NotLike,
-                    right: Box::new(ASTNode::SQLValue(Value::SingleQuotedString(
-                        "%a".to_string()
-                    ))),
-                },
-                *selection.unwrap()
-            );
-        }
-        _ => assert!(false),
-    }
-}