Extend lambda support for ClickHouse and DuckDB dialects

src/ast/mod.rs

@@ -1045,7 +1045,9 @@ pub enum Expr {
     /// param -> expr | (param1, ...) -> expr
     /// ```
     ///
-    /// See <https://docs.databricks.com/en/sql/language-manual/sql-ref-lambda-functions.html>.
+    /// [ClickHouse](https://clickhouse.com/docs/en/sql-reference/functions#higher-order-functions---operator-and-lambdaparams-expr-function)
+    /// [Databricks](https://docs.databricks.com/en/sql/language-manual/sql-ref-lambda-functions.html)
+    /// [DuckDb](https://duckdb.org/docs/sql/functions/lambda.html)
     Lambda(LambdaFunction),
 }
 

src/dialect/clickhouse.rs

@@ -70,4 +70,13 @@ impl Dialect for ClickHouseDialect {
     fn supports_dictionary_syntax(&self) -> bool {
         true
     }
+
+    /// See <https://clickhouse.com/docs/en/sql-reference/functions#higher-order-functions---operator-and-lambdaparams-expr-function>
+    fn supports_lambda_functions(&self) -> bool {
+        true
+    }
+
+    fn supports_parensless_lambda_functions(&self) -> bool {
+        true
+    }
 }

src/dialect/databricks.rs

@@ -51,6 +51,10 @@ impl Dialect for DatabricksDialect {
         true
     }
 
+    fn supports_parensless_lambda_functions(&self) -> bool {
+        true
+    }
+
     // https://docs.databricks.com/en/sql/language-manual/sql-ref-syntax-qry-select.html#syntax
     fn supports_select_wildcard_except(&self) -> bool {
         true

src/dialect/duckdb.rs

@@ -65,6 +65,15 @@ impl Dialect for DuckDbDialect {
         true
     }
 
+    /// See <https://duckdb.org/docs/sql/functions/lambda.html>
+    fn supports_lambda_functions(&self) -> bool {
+        true
+    }
+
+    fn supports_parensless_lambda_functions(&self) -> bool {
+        true
+    }
+
     // DuckDB is compatible with PostgreSQL syntax for this statement,
     // although not all features may be implemented.
     fn supports_explain_with_utility_options(&self) -> bool {

src/dialect/generic.rs

@@ -84,6 +84,10 @@ impl Dialect for GenericDialect {
         true
     }
 
+    fn supports_lambda_functions(&self) -> bool {
+        true
+    }
+
     fn allow_extract_custom(&self) -> bool {
         true
     }

src/dialect/mod.rs

@@ -340,12 +340,21 @@ pub trait Dialect: Debug + Any {
     /// Returns true if the dialect supports lambda functions, for example:
     ///
     /// ```sql
-    /// SELECT transform(array(1, 2, 3), x -> x + 1); -- returns [2,3,4]
+    /// SELECT transform(array(1, 2, 3), (x) -> x + 1); -- returns [2,3,4]
     /// ```
     fn supports_lambda_functions(&self) -> bool {
         false
     }
 
+    /// Returns true if the dialect supports lambda functions without parentheses for a single argument, for example:
+    ///
+    /// ```sql
+    /// SELECT transform(array(1, 2, 3), x -> x + 1); -- returns [2,3,4]
+    /// ```
+    fn supports_parensless_lambda_functions(&self) -> bool {
+        false
+    }
+
     /// Returns true if the dialect supports method calls, for example:
     ///
     /// ```sql

src/parser/mod.rs

@@ -1268,7 +1268,7 @@ impl<'a> Parser<'a> {
                     value: self.parse_introduced_string_value()?,
                 })
             }
-            Token::Arrow if self.dialect.supports_lambda_functions() => {
+            Token::Arrow if self.dialect.supports_parensless_lambda_functions() => {
                 self.expect_token(&Token::Arrow)?;
                 Ok(Expr::Lambda(LambdaFunction {
                     params: OneOrManyWithParens::One(w.clone().into_ident(w_span)),

tests/sqlparser_common.rs

@@ -13285,3 +13285,98 @@ fn test_trailing_commas_in_from() {
         "SELECT 1, 2 FROM (SELECT * FROM t1), (SELECT * FROM t2)",
     );
 }
+
+#[test]
+fn test_lambdas() {
+    let dialects = all_dialects_where(|d| d.supports_lambda_functions());
+
+    #[rustfmt::skip]
+    let sql = concat!(
+        "SELECT array_sort(array('Hello', 'World'), ",
+            "(p1, p2) -> CASE WHEN p1 = p2 THEN 0 ",
+                        "WHEN reverse(p1) < reverse(p2) THEN -1 ",
+                        "ELSE 1 END)",
+    );
+    pretty_assertions::assert_eq!(
+        SelectItem::UnnamedExpr(call(
+            "array_sort",
+            [
+                call(
+                    "array",
+                    [
+                        Expr::Value(Value::SingleQuotedString("Hello".to_owned())),
+                        Expr::Value(Value::SingleQuotedString("World".to_owned()))
+                    ]
+                ),
+                Expr::Lambda(LambdaFunction {
+                    params: OneOrManyWithParens::Many(vec![Ident::new("p1"), Ident::new("p2")]),
+                    body: Box::new(Expr::Case {
+                        operand: None,
+                        conditions: vec![
+                            Expr::BinaryOp {
+                                left: Box::new(Expr::Identifier(Ident::new("p1"))),
+                                op: BinaryOperator::Eq,
+                                right: Box::new(Expr::Identifier(Ident::new("p2")))
+                            },
+                            Expr::BinaryOp {
+                                left: Box::new(call(
+                                    "reverse",
+                                    [Expr::Identifier(Ident::new("p1"))]
+                                )),
+                                op: BinaryOperator::Lt,
+                                right: Box::new(call(
+                                    "reverse",
+                                    [Expr::Identifier(Ident::new("p2"))]
+                                ))
+                            }
+                        ],
+                        results: vec![
+                            Expr::Value(number("0")),
+                            Expr::UnaryOp {
+                                op: UnaryOperator::Minus,
+                                expr: Box::new(Expr::Value(number("1")))
+                            }
+                        ],
+                        else_result: Some(Box::new(Expr::Value(number("1"))))
+                    })
+                })
+            ]
+        )),
+        dialects.verified_only_select(sql).projection[0]
+    );
+
+    dialects.verified_expr(
+        "map_zip_with(map(1, 'a', 2, 'b'), map(1, 'x', 2, 'y'), (k, v1, v2) -> concat(v1, v2))",
+    );
+    dialects.verified_expr("transform(array(1, 2, 3), (x) -> x + 1)");
+}
+
+#[test]
+fn test_parensless_lambdas() {
+    let dialects = all_dialects_where(|d| d.supports_parensless_lambda_functions());
+
+    pretty_assertions::assert_eq!(
+        call(
+            "transform",
+            [
+                call(
+                    "array",
+                    [
+                        Expr::Value(number("1")),
+                        Expr::Value(number("2")),
+                        Expr::Value(number("3")),
+                    ]
+                ),
+                Expr::Lambda(LambdaFunction {
+                    params: OneOrManyWithParens::One(Ident::new("x")),
+                    body: Box::new(Expr::BinaryOp {
+                        left: Box::new(Expr::Identifier(Ident::new("x"))),
+                        op: BinaryOperator::Plus,
+                        right: Box::new(Expr::Value(number("1")))
+                    })
+                })
+            ]
+        ),
+        dialects.verified_expr("transform(array(1, 2, 3), x -> x + 1)")
+    );
+}

tests/sqlparser_databricks.rs

@@ -83,69 +83,6 @@ fn test_databricks_exists() {
     );
 }
 
-#[test]
-fn test_databricks_lambdas() {
-    #[rustfmt::skip]
-    let sql = concat!(
-        "SELECT array_sort(array('Hello', 'World'), ",
-            "(p1, p2) -> CASE WHEN p1 = p2 THEN 0 ",
-                        "WHEN reverse(p1) < reverse(p2) THEN -1 ",
-                        "ELSE 1 END)",
-    );
-    pretty_assertions::assert_eq!(
-        SelectItem::UnnamedExpr(call(
-            "array_sort",
-            [
-                call(
-                    "array",
-                    [
-                        Expr::Value(Value::SingleQuotedString("Hello".to_owned())),
-                        Expr::Value(Value::SingleQuotedString("World".to_owned()))
-                    ]
-                ),
-                Expr::Lambda(LambdaFunction {
-                    params: OneOrManyWithParens::Many(vec![Ident::new("p1"), Ident::new("p2")]),
-                    body: Box::new(Expr::Case {
-                        operand: None,
-                        conditions: vec![
-                            Expr::BinaryOp {
-                                left: Box::new(Expr::Identifier(Ident::new("p1"))),
-                                op: BinaryOperator::Eq,
-                                right: Box::new(Expr::Identifier(Ident::new("p2")))
-                            },
-                            Expr::BinaryOp {
-                                left: Box::new(call(
-                                    "reverse",
-                                    [Expr::Identifier(Ident::new("p1"))]
-                                )),
-                                op: BinaryOperator::Lt,
-                                right: Box::new(call(
-                                    "reverse",
-                                    [Expr::Identifier(Ident::new("p2"))]
-                                ))
-                            }
-                        ],
-                        results: vec![
-                            Expr::Value(number("0")),
-                            Expr::UnaryOp {
-                                op: UnaryOperator::Minus,
-                                expr: Box::new(Expr::Value(number("1")))
-                            }
-                        ],
-                        else_result: Some(Box::new(Expr::Value(number("1"))))
-                    })
-                })
-            ]
-        )),
-        databricks().verified_only_select(sql).projection[0]
-    );
-
-    databricks().verified_expr(
-        "map_zip_with(map(1, 'a', 2, 'b'), map(1, 'x', 2, 'y'), (k, v1, v2) -> concat(v1, v2))",
-    );
-    databricks().verified_expr("transform(array(1, 2, 3), x -> x + 1)");
-}
-
 #[test]
 fn test_values_clause() {
     let values = Values {

tests/sqlparser_postgres.rs

@@ -2749,7 +2749,7 @@ fn test_json() {
     );
 
     let sql = "SELECT params -> 'name' FROM events";
-    let select = pg().verified_only_select(sql);
+    let select = pg_and_generic().verified_only_select(sql);
     assert_eq!(
         SelectItem::UnnamedExpr(Expr::BinaryOp {
             left: Box::new(Expr::Identifier(Ident::new("params"))),
@@ -2760,7 +2760,7 @@ fn test_json() {
     );
 
     let sql = "SELECT info -> 'items' ->> 'product' FROM orders";
-    let select = pg().verified_only_select(sql);
+    let select = pg_and_generic().verified_only_select(sql);
     assert_eq!(
         SelectItem::UnnamedExpr(Expr::BinaryOp {
             left: Box::new(Expr::BinaryOp {
@@ -2778,7 +2778,7 @@ fn test_json() {
 
     // the RHS can be a number (array element access)
     let sql = "SELECT obj -> 42";
-    let select = pg().verified_only_select(sql);
+    let select = pg_and_generic().verified_only_select(sql);
     assert_eq!(
         SelectItem::UnnamedExpr(Expr::BinaryOp {
             left: Box::new(Expr::Identifier(Ident::new("obj"))),
@@ -2790,7 +2790,7 @@ fn test_json() {
 
     // the RHS can be an identifier
     let sql = "SELECT obj -> key";
-    let select = pg().verified_only_select(sql);
+    let select = pg_and_generic().verified_only_select(sql);
     assert_eq!(
         SelectItem::UnnamedExpr(Expr::BinaryOp {
             left: Box::new(Expr::Identifier(Ident::new("obj"))),
@@ -2802,7 +2802,7 @@ fn test_json() {
 
     // -> operator has lower precedence than arithmetic ops
     let sql = "SELECT obj -> 3 * 2";
-    let select = pg().verified_only_select(sql);
+    let select = pg_and_generic().verified_only_select(sql);
     assert_eq!(
         SelectItem::UnnamedExpr(Expr::BinaryOp {
             left: Box::new(Expr::Identifier(Ident::new("obj"))),