Support DuckDB's lambda x, y : expr syntax

DuckDB's recommended lambda syntax, `lambda x, y : expr`, had no rule: `lambda x : x + 1`
only parsed by accident, as a column named `lambda` followed by a JSON path, and a
condition body (`lambda x : x > 0`, `lambda x : x IS NOT NULL`) or several parameters
(`lambda acc, x : acc + x`) were rejected. These are the common forms in `list_filter`
and `list_reduce`.

`DuckDBLambdaExpression()` parses it into a `LambdaExpression` flagged with
`isLambdaKeyword()`, which deparses it as written. `LAMBDA` is a non-reserved keyword,
so it remains usable as a name.

Author: Jules Ivanic

src/main/java/net/sf/jsqlparser/expression/LambdaExpression.java

@@ -22,6 +22,7 @@ public class LambdaExpression extends ASTNodeAccessImpl implements Expression {
     private List<String> identifiers;
     private Expression expression;
     private boolean parenthesized;
+    private boolean lambdaKeyword;
 
     public LambdaExpression(String identifier, Expression expression) {
         this.identifiers = Collections.singletonList(identifier);
@@ -53,6 +54,16 @@ public LambdaExpression setParenthesized(boolean parenthesized) {
         return this;
     }
 
+    /** Whether it was written with DuckDB's lambda keyword: {@code lambda x, y : expr}. */
+    public boolean isLambdaKeyword() {
+        return lambdaKeyword;
+    }
+
+    public LambdaExpression setLambdaKeyword(boolean lambdaKeyword) {
+        this.lambdaKeyword = lambdaKeyword;
+        return this;
+    }
+
     public List<String> getIdentifiers() {
         return identifiers;
     }
@@ -76,6 +87,11 @@ public StringBuilder appendTo(StringBuilder builder) {
     }
 
     public StringBuilder appendTo(StringBuilder builder, Consumer<Expression> expressionPrinter) {
+        if (lambdaKeyword) {
+            builder.append("lambda ").append(String.join(", ", identifiers)).append(" : ");
+            expressionPrinter.accept(expression);
+            return builder;
+        }
         if (identifiers.size() == 1 && !parenthesized) {
             builder.append(identifiers.get(0));
         } else {

src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt

@@ -2601,6 +2601,7 @@ String NonReservedWord() :
       | tk=<K_KEYS:"KEYS">
       | tk=<K_KILL:"KILL">
       | tk=<K_FN:"FN">
+      | tk=<K_LAMBDA: "LAMBDA">
       | tk=<K_LAST: "LAST">
       | tk=<K_LEADING:"LEADING">
       | tk=<K_LESS:"LESS">
@@ -11430,6 +11431,10 @@ Expression PrimaryExpression() #PrimaryExpression:
         | LOOKAHEAD({ !interrupted && isCharacterSetIntroducedStringAhead() })
                   retval=CharacterSetIntroducedString()
 
+        // DuckDB's lambda x, y : expr, before Column() which would take LAMBDA as a column name
+        | LOOKAHEAD( <K_LAMBDA> RelObjectName() ( "," RelObjectName() )* ":", {!interrupted} )
+                  retval=DuckDBLambdaExpression()
+
         | LOOKAHEAD(2, {!interrupted}) retval=Column()
             [
                 LOOKAHEAD( "(" "+" ")" ("," | ")") )
@@ -13263,6 +13268,28 @@ LambdaExpression LambdaExpression() #LambdaExpression:
     }
 }
 
+/**
+ * DuckDB's lambda syntax, lambda x, y : expr, equivalent to (x, y) -> expr.
+ */
+LambdaExpression DuckDBLambdaExpression() #LambdaExpression:
+{
+    List<String> identifiers = new ArrayList<String>();
+    String s;
+    Expression expression;
+    LambdaExpression lambdaExpression;
+}
+{
+    <K_LAMBDA> s = RelObjectName() { identifiers.add(s); }
+    ( "," s = RelObjectName() { identifiers.add(s); } )*
+    ":"
+    expression = Expression()
+    {
+        lambdaExpression = new LambdaExpression(identifiers, expression).setLambdaKeyword(true);
+        linkAST(lambdaExpression,jjtThis);
+        return lambdaExpression;
+    }
+}
+
 RowPatternFunction RowPatternFunction() #RowPatternFunction:
 {
     RowPatternFunction.EvaluationMode mode;

src/test/java/net/sf/jsqlparser/statement/select/DuckDBTest.java

@@ -10,6 +10,8 @@
 package net.sf.jsqlparser.statement.select;
 
 import net.sf.jsqlparser.JSQLParserException;
+import net.sf.jsqlparser.expression.Function;
+import net.sf.jsqlparser.expression.LambdaExpression;
 import net.sf.jsqlparser.schema.Table;
 import net.sf.jsqlparser.statement.create.table.CreateTable;
 import net.sf.jsqlparser.statement.insert.Insert;
@@ -30,6 +32,8 @@
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
+import java.util.Arrays;
+
 public class DuckDBTest {
 
     @Test
@@ -689,4 +693,40 @@ void testRecursiveCteWithoutUsingKey() throws JSQLParserException {
 
         Assertions.assertNull(select.getWithItemsList().get(0).getUsingKeyExpressions());
     }
+
+    @Test
+    void testLambdaKeyword() throws JSQLParserException {
+        TestUtils.assertSqlCanBeParsedAndDeparsed(
+                "SELECT list_transform(l, lambda x : x + 1) FROM t", true);
+        TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT list_filter(l, lambda x : x > 0) FROM t",
+                true);
+        TestUtils.assertSqlCanBeParsedAndDeparsed(
+                "SELECT list_filter(l, lambda x : x IS NOT NULL AND x <> 'a') FROM t", true);
+        TestUtils.assertSqlCanBeParsedAndDeparsed(
+                "SELECT list_reduce(l, lambda acc, x : acc + x) FROM t", true);
+        TestUtils.assertSqlCanBeParsedAndDeparsed(
+                "SELECT list_filter([(CASE WHEN a THEN 1 END)], lambda x : x IS NOT NULL) FROM t",
+                true);
+        TestUtils.assertSqlCanBeParsedAndDeparsed(
+                "SELECT list_transform(l, lambda x : list_filter(x, lambda y : y > 1)) FROM t",
+                true);
+    }
+
+    @Test
+    void testLambdaKeywordExpression() throws JSQLParserException {
+        PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(
+                "SELECT list_reduce(l, lambda acc, x : acc + x) FROM t", true);
+        Function function = select.getSelectItem(0).getExpression(Function.class);
+        LambdaExpression lambda = (LambdaExpression) function.getParameters().get(1);
+
+        Assertions.assertTrue(lambda.isLambdaKeyword());
+        Assertions.assertEquals(Arrays.asList("acc", "x"), lambda.getIdentifiers());
+    }
+
+    @Test
+    void testLambdaAsIdentifier() throws JSQLParserException {
+        TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT lambda FROM t", true);
+        TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT lambda x, y FROM t", true);
+        TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT t.lambda FROM lambda t", true);
+    }
 }