Support DuckDB 2.0 recursive CTEs with USING KEY

Adds WITH RECURSIVE tbl (a, b) USING KEY (a, avg(b)) AS (...), which
aggregates a recursive CTE by key instead of accumulating every row.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EqinwHBKuAtPEmtXr3b5P2

Author: hayssams

src/main/java/net/sf/jsqlparser/statement/select/WithItem.java

@@ -11,6 +11,7 @@
 
 import java.util.function.Consumer;
 import net.sf.jsqlparser.expression.Expression;
+import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
 
 import java.io.Serializable;
 import java.util.ArrayList;
@@ -35,6 +36,7 @@ public class WithItem<K extends ParenthesedStatement> implements Serializable {
     private boolean recursive = false;
     private boolean usingNot = false;
     private boolean materialized = false;
+    private ExpressionList<Expression> usingKeyExpressions;
 
     public WithItem(K statement, Alias alias) {
         this.statement = statement;
@@ -166,6 +168,23 @@ public WithItem<K> withCycleClause(WithCycleClause cycleClause) {
         return this;
     }
 
+    /**
+     * DuckDB 2.0 aggregates a recursive CTE by key:
+     * {@code WITH RECURSIVE tbl (a, b) USING KEY (a, avg(b)) AS (...)}.
+     */
+    public ExpressionList<Expression> getUsingKeyExpressions() {
+        return usingKeyExpressions;
+    }
+
+    public void setUsingKeyExpressions(ExpressionList<Expression> usingKeyExpressions) {
+        this.usingKeyExpressions = usingKeyExpressions;
+    }
+
+    public WithItem<K> withUsingKeyExpressions(ExpressionList<Expression> usingKeyExpressions) {
+        setUsingKeyExpressions(usingKeyExpressions);
+        return this;
+    }
+
     public StringBuilder appendRecursiveClausesTo(StringBuilder builder,
             Consumer<Expression> expressionPrinter) {
         if (searchClause != null) {
@@ -197,6 +216,9 @@ public String toString() {
                 }
                 builder.append(")");
             }
+            if (usingKeyExpressions != null) {
+                builder.append(" USING KEY (").append(usingKeyExpressions).append(")");
+            }
             builder.append(" AS ");
             if (materialized) {
                 builder.append(usingNot

src/main/java/net/sf/jsqlparser/util/deparser/DmlDeParserSupport.java

@@ -93,6 +93,9 @@ <S> StringBuilder deparseWithItem(WithItem<?> item, S context) {
             builder.append(' ')
                     .append(PlainSelect.getStringList(item.getWithItemList(), true, true));
         }
+        if (item.getUsingKeyExpressions() != null) {
+            builder.append(" USING KEY (").append(item.getUsingKeyExpressions()).append(")");
+        }
         builder.append(" AS ");
         if (item.isMaterialized()) {
             builder.append(item.isUsingNot() ? "NOT MATERIALIZED " : "MATERIALIZED ");

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

@@ -7374,6 +7374,7 @@ WithItem<?> WithItem() #WithItem:
     ParenthesedStatement statement = null;
     WithSearchClause withSearchClause = null;
     WithCycleClause withCycleClause = null;
+    ExpressionList<Expression> usingKeyExpressions = null;
     WithItem<?> withItem;
 }
 {
@@ -7388,6 +7389,8 @@ WithItem<?> WithItem() #WithItem:
              [ LOOKAHEAD(2) <K_RECURSIVE>  { recursive = true; } ]
              name=RelObjectName()
              [ "(" selectItems=SelectItemsList() ")" ]
+             // DuckDB 2.0: WITH RECURSIVE tbl (a, b) USING KEY (a, avg(b)) AS (...)
+             [ LOOKAHEAD(2) <K_USING> <K_KEY> "(" usingKeyExpressions=ExpressionList() ")" ]
              <K_AS>
              [ LOOKAHEAD(2) [ <K_NOT> { usingNot = true; } ] <K_MATERIALIZED>  { materialized = true; } ]
              (
@@ -7403,6 +7406,7 @@ WithItem<?> WithItem() #WithItem:
                 withItem = new WithItem(statement, new Alias(name, false))
                     .withRecursive(recursive, usingNot, materialized)
                     .withWithItemList(selectItems);
+                withItem.setUsingKeyExpressions(usingKeyExpressions);
              }
          )
      )

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

@@ -661,4 +661,28 @@ void testApproxRemainsUsableAsIdentifier() throws JSQLParserException {
         String sqlStr = "SELECT approx, nearest, similarity FROM t";
         TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
     }
+
+    @Test
+    void testRecursiveCteUsingKey() throws JSQLParserException {
+        String sqlStr = "WITH RECURSIVE tbl (a, b) USING KEY (a, avg(b)) AS "
+                + "(SELECT 1, 2 UNION ALL SELECT a + 1, b FROM tbl WHERE a < 3) SELECT * FROM tbl";
+        PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+        WithItem<?> withItem = select.getWithItemsList().get(0);
+
+        Assertions.assertEquals(2, withItem.getUsingKeyExpressions().size());
+    }
+
+    @Test
+    void testRecursiveCteUsingKeySingleColumn() throws JSQLParserException {
+        String sqlStr = "WITH RECURSIVE tbl USING KEY (a) AS (SELECT 1 AS a) SELECT * FROM tbl";
+        TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+    }
+
+    @Test
+    void testRecursiveCteWithoutUsingKey() throws JSQLParserException {
+        String sqlStr = "WITH RECURSIVE tbl (a) AS (SELECT 1) SELECT * FROM tbl";
+        PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+
+        Assertions.assertNull(select.getWithItemsList().get(0).getUsingKeyExpressions());
+    }
 }