From 17b27d9282c1a5944ad72257d2bfb15eac10c3be Mon Sep 17 00:00:00 2001 From: Andrew Lamb Date: Wed, 19 Jul 2023 16:15:29 -0400 Subject: [PATCH] Revert inconsistent argument to all_dialects --- src/parser.rs | 6 +++--- src/test_utils.rs | 4 ++-- tests/sqlparser_common.rs | 44 +++++++++++++++++++-------------------- 3 files changed, 27 insertions(+), 27 deletions(-) diff --git a/src/parser.rs b/src/parser.rs index 8dcd17839..790ba8fbb 100644 --- a/src/parser.rs +++ b/src/parser.rs @@ -7295,7 +7295,7 @@ mod tests { #[test] fn test_prev_index() { let sql = "SELECT version"; - all_dialects(None).run_parser_method(sql, |parser| { + all_dialects().run_parser_method(sql, |parser| { assert_eq!(parser.peek_token(), Token::make_keyword("SELECT")); assert_eq!(parser.next_token(), Token::make_keyword("SELECT")); parser.prev_token(); @@ -7650,7 +7650,7 @@ mod tests { // The expected name should be identical as the input name, that's why I don't receive both macro_rules! test_parse_schema_name { ($input:expr, $expected_name:expr $(,)?) => {{ - all_dialects(None).run_parser_method(&*$input, |parser| { + all_dialects().run_parser_method(&*$input, |parser| { let schema_name = parser.parse_schema_name().unwrap(); // Validate that the structure is the same as expected assert_eq!(schema_name, $expected_name); @@ -7862,7 +7862,7 @@ mod tests { fn test_parse_multipart_identifier_negative() { macro_rules! test_parse_multipart_identifier_error { ($input:expr, $expected_err:expr $(,)?) => {{ - all_dialects(None).run_parser_method(&*$input, |parser| { + all_dialects().run_parser_method(&*$input, |parser| { let actual_err = parser.parse_multipart_identifier().unwrap_err(); assert_eq!(actual_err.to_string(), $expected_err); }); diff --git a/src/test_utils.rs b/src/test_utils.rs index 380907e70..47fb00d5d 100644 --- a/src/test_utils.rs +++ b/src/test_utils.rs @@ -155,7 +155,7 @@ impl TestedDialects { } } -pub fn all_dialects(options: Option) -> TestedDialects { +pub fn all_dialects() -> TestedDialects { TestedDialects { dialects: vec![ Box::new(GenericDialect {}), @@ -170,7 +170,7 @@ pub fn all_dialects(options: Option) -> TestedDialects { Box::new(SQLiteDialect {}), Box::new(DuckDbDialect {}), ], - options, + options: None, } } diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs index 1e962968c..356926e13 100644 --- a/tests/sqlparser_common.rs +++ b/tests/sqlparser_common.rs @@ -373,14 +373,14 @@ fn parse_select_with_table_alias() { #[test] fn parse_invalid_table_name() { - let ast = all_dialects(None) + 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(None).run_parser_method("", |parser| parser.parse_object_name()); + let ast = all_dialects().run_parser_method("", |parser| parser.parse_object_name()); assert!(ast.is_err()); } @@ -898,7 +898,7 @@ fn parse_invalid_infix_not() { fn parse_collate() { let sql = "SELECT name COLLATE \"de_DE\" FROM customer"; assert_matches!( - only(&all_dialects(None).verified_only_select(sql).projection), + only(&all_dialects().verified_only_select(sql).projection), SelectItem::UnnamedExpr(Expr::Collate { .. }) ); } @@ -907,7 +907,7 @@ fn parse_collate() { fn parse_collate_after_parens() { let sql = "SELECT (name) COLLATE \"de_DE\" FROM customer"; assert_matches!( - only(&all_dialects(None).verified_only_select(sql).projection), + only(&all_dialects().verified_only_select(sql).projection), SelectItem::UnnamedExpr(Expr::Collate { .. }) ); } @@ -1154,15 +1154,15 @@ fn pg_and_generic() -> TestedDialects { fn parse_json_ops_without_colon() { use self::JsonOperator; let binary_ops = &[ - ("->", JsonOperator::Arrow, all_dialects(None)), - ("->>", JsonOperator::LongArrow, all_dialects(None)), + ("->", JsonOperator::Arrow, all_dialects()), + ("->>", JsonOperator::LongArrow, all_dialects()), ("#>", JsonOperator::HashArrow, pg_and_generic()), ("#>>", JsonOperator::HashLongArrow, pg_and_generic()), - ("@>", JsonOperator::AtArrow, all_dialects(None)), - ("<@", JsonOperator::ArrowAt, all_dialects(None)), + ("@>", JsonOperator::AtArrow, all_dialects()), + ("<@", JsonOperator::ArrowAt, all_dialects()), ("#-", JsonOperator::HashMinus, pg_and_generic()), - ("@?", JsonOperator::AtQuestion, all_dialects(None)), - ("@@", JsonOperator::AtAt, all_dialects(None)), + ("@?", JsonOperator::AtQuestion, all_dialects()), + ("@@", JsonOperator::AtAt, all_dialects()), ]; for (str_op, op, dialects) in binary_ops { @@ -1473,7 +1473,7 @@ fn parse_string_agg() { /// selects all dialects but PostgreSQL pub fn all_dialects_but_pg() -> TestedDialects { TestedDialects { - dialects: all_dialects(None) + dialects: all_dialects() .dialects .into_iter() .filter(|x| !x.is::()) @@ -1486,8 +1486,8 @@ pub fn all_dialects_but_pg() -> TestedDialects { fn parse_bitwise_ops() { let bitwise_ops = &[ ("^", BinaryOperator::BitwiseXor, all_dialects_but_pg()), - ("|", BinaryOperator::BitwiseOr, all_dialects(None)), - ("&", BinaryOperator::BitwiseAnd, all_dialects(None)), + ("|", BinaryOperator::BitwiseOr, all_dialects()), + ("&", BinaryOperator::BitwiseAnd, all_dialects()), ]; for (str_op, op, dialects) in bitwise_ops { @@ -2716,7 +2716,7 @@ fn parse_create_table_clone() { #[test] fn parse_create_table_trailing_comma() { let sql = "CREATE TABLE foo (bar int,)"; - all_dialects(None).one_statement_parses_to(sql, "CREATE TABLE foo (bar INT)"); + all_dialects().one_statement_parses_to(sql, "CREATE TABLE foo (bar INT)"); } #[test] @@ -4875,7 +4875,7 @@ fn parse_ctes() { #[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(None).verified_query(sql); + let query = all_dialects().verified_query(sql); assert_eq!( vec![Ident::new("col1"), Ident::new("col2")], query @@ -6589,27 +6589,27 @@ fn all_keywords_sorted() { } fn parse_sql_statements(sql: &str) -> Result, ParserError> { - all_dialects(None).parse_sql_statements(sql) + all_dialects().parse_sql_statements(sql) } fn one_statement_parses_to(sql: &str, canonical: &str) -> Statement { - all_dialects(None).one_statement_parses_to(sql, canonical) + all_dialects().one_statement_parses_to(sql, canonical) } fn verified_stmt(query: &str) -> Statement { - all_dialects(None).verified_stmt(query) + all_dialects().verified_stmt(query) } fn verified_query(query: &str) -> Query { - all_dialects(None).verified_query(query) + all_dialects().verified_query(query) } fn verified_only_select(query: &str) -> Select { - all_dialects(None).verified_only_select(query) + all_dialects().verified_only_select(query) } fn verified_expr(query: &str) -> Expr { - all_dialects(None).verified_expr(query) + all_dialects().verified_expr(query) } #[test] @@ -6909,7 +6909,7 @@ fn parse_cache_table() { let sql = "SELECT a, b, c FROM foo"; let cache_table_name = "cache_table_name"; let table_flag = "flag"; - let query = all_dialects(None).verified_query(sql); + let query = all_dialects().verified_query(sql); assert_eq!( verified_stmt(format!("CACHE TABLE '{cache_table_name}'").as_str()),