tests: generalize comma-separated TRIM coverage by dialect

Move two-argument TRIM assertions from postgres-only tests into the
common parser suite and select dialects via
supports_comma_separated_trim().

Keep explicit failure coverage for dialects that do not support comma
syntax and remove the redundant postgres-specific test.

Author: LucaCappelletti94

tests/sqlparser_common.rs

@@ -8099,22 +8099,46 @@ fn parse_trim() {
         parse_sql_statements("SELECT TRIM(FOO 'xyz' FROM 'xyzfooxyz')").unwrap_err()
     );
 
-    // keep dialects without comma-style TRIM syntax failing
-    let all_expected_error = TestedDialects::new(vec![
-        //Box::new(GenericDialect {}),
-        Box::new(MsSqlDialect {}),
-        Box::new(AnsiDialect {}),
-        //Box::new(SnowflakeDialect {}),
-        Box::new(HiveDialect {}),
-        Box::new(RedshiftSqlDialect {}),
-        Box::new(MySqlDialect {}),
-        //Box::new(BigQueryDialect {}),
-        Box::new(SQLiteDialect {}),
-    ]);
+    // dialects that support comma-separated TRIM syntax
+    let dialects = all_dialects_where(|d| d.supports_comma_separated_trim());
+
+    let sql = "SELECT TRIM('  xyz  ', ' ')";
+    let select = dialects.verified_only_select(sql);
+    assert_eq!(
+        &Expr::Trim {
+            expr: Box::new(Expr::Value(
+                Value::SingleQuotedString("  xyz  ".to_owned()).with_empty_span()
+            )),
+            trim_where: None,
+            trim_what: None,
+            trim_characters: Some(vec![Expr::Value(
+                Value::SingleQuotedString(" ".to_owned()).with_empty_span()
+            )]),
+        },
+        expr_from_projection(only(&select.projection))
+    );
+
+    let sql = "SELECT TRIM('xyz', 'a')";
+    let select = dialects.verified_only_select(sql);
+    assert_eq!(
+        &Expr::Trim {
+            expr: Box::new(Expr::Value(
+                Value::SingleQuotedString("xyz".to_owned()).with_empty_span()
+            )),
+            trim_where: None,
+            trim_what: None,
+            trim_characters: Some(vec![Expr::Value(
+                Value::SingleQuotedString("a".to_owned()).with_empty_span()
+            )]),
+        },
+        expr_from_projection(only(&select.projection))
+    );
 
+    // dialects without comma-style TRIM syntax should fail
+    let unsupported_dialects = all_dialects_where(|d| !d.supports_comma_separated_trim());
     assert_eq!(
-        ParserError::ParserError("Expected: ), found: 'a'".to_owned()),
-        all_expected_error
+        ParserError::ParserError("Expected: ), found: ,".to_owned()),
+        unsupported_dialects
             .parse_sql_statements("SELECT TRIM('xyz', 'a')")
             .unwrap_err()
     );

tests/sqlparser_postgres.rs

@@ -8641,44 +8641,3 @@ fn parse_pg_analyze() {
         _ => panic!("Expected Analyze, got: {stmt:?}"),
     }
 }
-
-#[test]
-fn parse_postgres_two_argument_trim() {
-    let sql = "SELECT TRIM('  xyz  ', ' ')";
-    let select = pg().verified_only_select(sql);
-    assert_eq!(
-        &Expr::Trim {
-            expr: Box::new(Expr::Value(
-                Value::SingleQuotedString("  xyz  ".to_owned()).with_empty_span()
-            )),
-            trim_where: None,
-            trim_what: None,
-            trim_characters: Some(vec![Expr::Value(
-                Value::SingleQuotedString(" ".to_owned()).with_empty_span()
-            )]),
-        },
-        expr_from_projection(only(&select.projection))
-    );
-
-    let sql = "SELECT TRIM('xyz', 'a')";
-    let select = pg().verified_only_select(sql);
-    assert_eq!(
-        &Expr::Trim {
-            expr: Box::new(Expr::Value(
-                Value::SingleQuotedString("xyz".to_owned()).with_empty_span()
-            )),
-            trim_where: None,
-            trim_what: None,
-            trim_characters: Some(vec![Expr::Value(
-                Value::SingleQuotedString("a".to_owned()).with_empty_span()
-            )]),
-        },
-        expr_from_projection(only(&select.projection))
-    );
-
-    let error_sql = "SELECT TRIM('xyz' 'a')";
-    assert_eq!(
-        ParserError::ParserError("Expected: ), found: 'a'".to_owned()),
-        pg().parse_sql_statements(error_sql).unwrap_err()
-    );
-}