Enhance TRIM function support for PostgreSQL and add tests for two-argument TRIM syntax

Author: LucaCappelletti94

src/ast/mod.rs

@@ -1131,7 +1131,7 @@ pub enum Expr {
     /// ```sql
     /// TRIM([BOTH | LEADING | TRAILING] [<expr> FROM] <expr>)
     /// TRIM(<expr>)
-    /// TRIM(<expr>, [, characters]) -- only Snowflake or Bigquery
+    /// TRIM(<expr>, [, characters]) -- PostgreSQL, DuckDB, Snowflake, BigQuery, Generic
     /// ```
     Trim {
         /// The expression to trim from.

src/parser/mod.rs

@@ -2940,7 +2940,7 @@ impl<'a> Parser<'a> {
     /// ```sql
     /// TRIM ([WHERE] ['text' FROM] 'text')
     /// TRIM ('text')
-    /// TRIM(<expr>, [, characters]) -- only Snowflake or BigQuery
+    /// TRIM(<expr>, [, characters]) -- PostgreSQL, DuckDB, Snowflake, BigQuery, Generic
     /// ```
     pub fn parse_trim_expr(&mut self) -> Result<Expr, ParserError> {
         self.expect_token(&Token::LParen)?;
@@ -2962,7 +2962,13 @@ impl<'a> Parser<'a> {
                 trim_characters: None,
             })
         } else if self.consume_token(&Token::Comma)
-            && dialect_of!(self is DuckDbDialect | SnowflakeDialect | BigQueryDialect | GenericDialect)
+            && dialect_of!(
+                self is DuckDbDialect
+                    | SnowflakeDialect
+                    | BigQueryDialect
+                    | PostgreSqlDialect
+                    | GenericDialect
+            )
         {
             let characters = self.parse_comma_separated(Parser::parse_expr)?;
             self.expect_token(&Token::RParen)?;

tests/sqlparser_common.rs

@@ -8099,10 +8099,9 @@ fn parse_trim() {
         parse_sql_statements("SELECT TRIM(FOO 'xyz' FROM 'xyzfooxyz')").unwrap_err()
     );
 
-    //keep Snowflake/BigQuery TRIM syntax failing
-    let all_expected_snowflake = TestedDialects::new(vec![
+    // keep dialects without comma-style TRIM syntax failing
+    let all_expected_error = TestedDialects::new(vec![
         //Box::new(GenericDialect {}),
-        Box::new(PostgreSqlDialect {}),
         Box::new(MsSqlDialect {}),
         Box::new(AnsiDialect {}),
         //Box::new(SnowflakeDialect {}),
@@ -8115,7 +8114,7 @@ fn parse_trim() {
 
     assert_eq!(
         ParserError::ParserError("Expected: ), found: 'a'".to_owned()),
-        all_expected_snowflake
+        all_expected_error
             .parse_sql_statements("SELECT TRIM('xyz', 'a')")
             .unwrap_err()
     );

tests/sqlparser_postgres.rs

@@ -8641,3 +8641,44 @@ 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()
+    );
+}