removed confusing test_named_arguments_with_dialects test

reset to default dialect in named_arguments.slt after testing MsSQL dialect
compacted pattern matching in sql_fn_arg_to_logical_expr_with_name

Author: bubulalabu

datafusion/sql/src/expr/function.rs

@@ -707,23 +707,16 @@ impl<S: ContextProvider> SqlToRel<'_, S> {
             }
             // PostgreSQL dialect uses ExprNamed variant with expression for name
             FunctionArg::ExprNamed {
-                name,
+                name: SQLExpr::Identifier(name),
                 arg: FunctionArgExpr::Expr(arg),
                 operator: _,
             } => {
                 let expr = self.sql_expr_to_logical_expr(arg, schema, planner_context)?;
-                let arg_name = match name {
-                    SQLExpr::Identifier(ident) => crate::utils::normalize_ident(ident),
-                    _ => {
-                        return plan_err!(
-                            "Named argument must use a simple identifier, got: {name:?}"
-                        )
-                    }
-                };
+                let arg_name = crate::utils::normalize_ident(name);
                 Ok((expr, Some(arg_name)))
             }
             FunctionArg::ExprNamed {
-                name,
+                name: SQLExpr::Identifier(name),
                 arg: FunctionArgExpr::Wildcard,
                 operator: _,
             } => {
@@ -732,14 +725,7 @@ impl<S: ContextProvider> SqlToRel<'_, S> {
                     qualifier: None,
                     options: Box::new(WildcardOptions::default()),
                 };
-                let arg_name = match name {
-                    SQLExpr::Identifier(ident) => crate::utils::normalize_ident(ident),
-                    _ => {
-                        return plan_err!(
-                            "Named argument must use a simple identifier, got: {name:?}"
-                        )
-                    }
-                };
+                let arg_name = crate::utils::normalize_ident(name);
                 Ok((expr, Some(arg_name)))
             }
             _ => not_impl_err!("Unsupported qualified wildcard argument: {sql:?}"),

datafusion/sql/tests/sql_integration.rs

@@ -31,7 +31,7 @@ use datafusion_expr::{
 };
 use datafusion_functions::{string, unicode};
 use datafusion_sql::{
-    parser::{DFParser, Statement as DFStatement},
+    parser::DFParser,
     planner::{NullOrdering, ParserOptions, SqlToRel},
 };
 
@@ -46,12 +46,7 @@ use datafusion_functions_nested::make_array::make_array_udf;
 use datafusion_functions_window::{rank::rank_udwf, row_number::row_number_udwf};
 use insta::{allow_duplicates, assert_snapshot};
 use rstest::rstest;
-use sqlparser::ast::{Expr as SQLExpr, FunctionArg, Statement};
-use sqlparser::dialect::{
-    AnsiDialect, BigQueryDialect, ClickHouseDialect, DatabricksDialect, Dialect,
-    DuckDbDialect, GenericDialect, HiveDialect, MsSqlDialect, MySqlDialect,
-    PostgreSqlDialect, RedshiftSqlDialect, SQLiteDialect, SnowflakeDialect,
-};
+use sqlparser::dialect::{Dialect, GenericDialect, HiveDialect, MySqlDialect};
 
 mod cases;
 mod common;
@@ -3954,79 +3949,6 @@ fn test_double_quoted_literal_string() {
     assert!(logical_plan("SELECT \"1\"").is_err());
 }
 
-#[test]
-fn test_named_arguments_with_dialects() {
-    let sql = "SELECT my_func(arg1 => 'value1')";
-
-    // Returns None if the dialect doesn't support the => operator
-    let extract_first_arg = |dialect: &dyn Dialect| -> Option<FunctionArg> {
-        let mut statements = DFParser::parse_sql_with_dialect(sql, dialect).ok()?;
-
-        let statement = statements.pop_front().unwrap();
-        if let DFStatement::Statement(stmt) = statement {
-            if let Statement::Query(query) = stmt.as_ref() {
-                if let sqlparser::ast::SetExpr::Select(select) = query.body.as_ref() {
-                    let projection = &select.projection[0];
-                    if let sqlparser::ast::SelectItem::UnnamedExpr(SQLExpr::Function(
-                        func,
-                    )) = projection
-                    {
-                        if let sqlparser::ast::FunctionArguments::List(arg_list) =
-                            &func.args
-                        {
-                            return Some(arg_list.args[0].clone());
-                        }
-                    }
-                }
-            }
-        }
-        panic!("Failed to extract function argument");
-    };
-
-    let arg = extract_first_arg(&AnsiDialect {});
-    assert!(matches!(arg, Some(FunctionArg::Named { name, .. }) if name.value == "arg1"));
-
-    let arg = extract_first_arg(&BigQueryDialect {});
-    assert!(matches!(arg, Some(FunctionArg::Named { name, .. }) if name.value == "arg1"));
-
-    let arg = extract_first_arg(&ClickHouseDialect {});
-    assert!(matches!(arg, Some(FunctionArg::Named { name, .. }) if name.value == "arg1"));
-
-    let arg = extract_first_arg(&DatabricksDialect {});
-    assert!(matches!(arg, Some(FunctionArg::Named { name, .. }) if name.value == "arg1"));
-
-    let arg = extract_first_arg(&DuckDbDialect {});
-    assert!(matches!(arg, Some(FunctionArg::Named { name, .. }) if name.value == "arg1"));
-
-    let arg = extract_first_arg(&GenericDialect {});
-    assert!(matches!(arg, Some(FunctionArg::Named { name, .. }) if name.value == "arg1"));
-
-    let arg = extract_first_arg(&HiveDialect {});
-    assert!(matches!(arg, Some(FunctionArg::Named { name, .. }) if name.value == "arg1"));
-
-    let arg = extract_first_arg(&MsSqlDialect {});
-    assert!(arg.is_none());
-
-    let arg = extract_first_arg(&MySqlDialect {});
-    assert!(matches!(arg, Some(FunctionArg::Named { name, .. }) if name.value == "arg1"));
-
-    let arg = extract_first_arg(&PostgreSqlDialect {});
-    assert!(matches!(
-        arg.as_ref(),
-        Some(FunctionArg::ExprNamed { name, .. })
-        if matches!(name, SQLExpr::Identifier(ident) if ident.value == "arg1")
-    ));
-
-    let arg = extract_first_arg(&RedshiftSqlDialect {});
-    assert!(matches!(arg, Some(FunctionArg::Named { name, .. }) if name.value == "arg1"));
-
-    let arg = extract_first_arg(&SQLiteDialect {});
-    assert!(matches!(arg, Some(FunctionArg::Named { name, .. }) if name.value == "arg1"));
-
-    let arg = extract_first_arg(&SnowflakeDialect {});
-    assert!(matches!(arg, Some(FunctionArg::Named { name, .. }) if name.value == "arg1"));
-}
-
 #[test]
 fn test_constant_expr_eq_join() {
     let sql = "SELECT id, order_id \

datafusion/sqllogictest/test_files/named_arguments.slt

@@ -133,3 +133,7 @@ set datafusion.sql_parser.dialect = 'MsSQL';
 # Error: MsSQL dialect does not support => operator
 query error DataFusion error: SQL error: ParserError\("Expected: \), found: => at Line: 1, Column: 19"\)
 SELECT substr(str => 'hello world', start_pos => 7, length => 5);
+
+# Reset to default dialect
+statement ok
+set datafusion.sql_parser.dialect = 'Generic';