DuckDB: accept FROM-first queries and TABLE t as subqueries and set operands

- `(FROM t ...)` is a sub-select wherever `(SELECT ...)` is, and a
  parenthesized `FROM t` without pipe operators is a FROM-first select.
- FROM-first queries and `TABLE t` are set operation operands, e.g.
  `FROM a UNION ALL FROM b` or `TABLE a EXCEPT TABLE b`, with a trailing
  ORDER BY/LIMIT applying to the whole operation.
- `WITH ... TABLE t` keeps and prints its WITH clause.
- The FROM-first scan follows the token chain and stops at the end of
  the enclosing parentheses.

Author: guizmaii

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

@@ -37,7 +37,13 @@ public StringBuilder appendSelectBodyTo(StringBuilder builder) {
     @SuppressWarnings({"PMD.CyclomaticComplexity"})
     @Override
     public StringBuilder appendTo(StringBuilder builder) {
-
+        if (withItemsList != null && !withItemsList.isEmpty()) {
+            builder.append("WITH ");
+            for (int i = 0; i < withItemsList.size(); i++) {
+                builder.append(i > 0 ? ", " : "").append(withItemsList.get(i));
+            }
+            builder.append(" ");
+        }
         appendSelectBodyTo(builder);
 
         builder.append(orderByToString(false, orderByElements));

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

@@ -13,6 +13,8 @@
 import net.sf.jsqlparser.statement.piped.FromQuery;
 import net.sf.jsqlparser.statement.select.*;
 
+import java.util.List;
+
 /**
  * @author jxnu-liguobin
  */
@@ -84,6 +86,18 @@ public <S> StringBuilder visit(LateralSubSelect lateralSubSelect, S context) {
 
     @Override
     public <S> StringBuilder visit(TableStatement tableStatement, S context) {
+        List<WithItem<?>> withItemsList = tableStatement.getWithItemsList();
+        if (withItemsList != null && !withItemsList.isEmpty()) {
+            SelectDeParser selectDeParser = new SelectDeParser(expressionVisitor, builder);
+            builder.append("WITH ");
+            for (int i = 0; i < withItemsList.size(); i++) {
+                if (i > 0) {
+                    builder.append(", ");
+                }
+                withItemsList.get(i).accept((SelectVisitor<?>) selectDeParser, context);
+            }
+            builder.append(" ");
+        }
         tableStatement.appendSelectBodyTo(builder);
         if (tableStatement.getOrderByElements() != null) {
             new OrderByDeParser(expressionVisitor, builder)

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

@@ -745,7 +745,7 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
             // Direct subquery: ( SELECT/WITH/PIVOT ) → ParenthesedSelect handles it
             // ( VALUES ) can be ParenthesedFromItem(Values) or ParenthesedSelect;
             // ParenthesedFromItem is checked first so Values-as-FROM-item works
-            if (k2 == K_SELECT || k2 == K_WITH || k2 == K_PIVOT) return false;
+            if (k2 == K_SELECT || k2 == K_WITH || k2 == K_PIVOT || k2 == K_FROM) return false;
             // ( ( SELECT ) UNION ( SELECT ) ) → isNestedSetOperationAhead handles it
             // Other (( patterns: ( (SELECT...) JOIN ... ) or ( (table) ) → ParenthesedFromItem
             if (k2 == K_LATERAL) return false; // handled by LateralSubSelect
@@ -781,7 +781,9 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
         try {
             if (getToken(1).kind != OPENING_BRACKET) return false;
             int k = getToken(2).kind;
-            return k == K_SELECT || k == K_WITH || k == K_VALUES;
+            // DuckDB's (FROM t ...) and (TABLE t), but not a TABLE(...) function
+            return k == K_SELECT || k == K_WITH || k == K_VALUES || k == K_FROM
+                    || k == K_TABLE && getToken(3).kind != OPENING_BRACKET;
         } catch (TokenMgrException e) {
             return false;
         }
@@ -1393,22 +1395,29 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
      * nested in brackets (a sub-select, for instance) do not count.
      */
     private boolean isFromFirstSelectAhead() {
-        if (getToken(1).kind != K_FROM) {
+        Token token = getToken(1);
+        if (token.kind != K_FROM) {
             return false;
         }
         int depth = 0;
-        for (int i = 2;; i++) {
-            Token token = getToken(i);
-            if (token == null || token.kind == EOF || ";".equals(token.image)
-                    || "|>".equals(token.image)) {
+        while (true) {
+            token = nextWithItemToken(token);
+            if (token.kind == EOF || ";".equals(token.image) || "|>".equals(token.image)) {
                 return false;
             }
             if ("(".equals(token.image)) {
                 depth++;
             } else if (")".equals(token.image)) {
-                depth--;
+                // the end of the parenthesized query this FROM starts, e.g. (FROM t)
+                if (--depth < 0) {
+                    return true;
+                }
             } else if (depth == 0) {
                 switch (token.kind) {
+                    case K_UNION:
+                    case K_EXCEPT:
+                    case K_INTERSECT:
+                    case K_MINUS:
                     case K_SELECT:
                     case K_WHERE:
                     case K_GROUP:
@@ -3475,8 +3484,6 @@ Statement SingleStatement() :
             |
             stm = Select()
             |
-            stm = TableStatement()
-            |
             LOOKAHEAD(3) stm = Upsert()
             |
             LOOKAHEAD(2) stm = Alter()
@@ -7170,12 +7177,15 @@ Select Select() #Select:
 {
     [ with=WithList() ]
     (
-        LOOKAHEAD({ isFromFirstSelectAhead() }) select = FromFirstSelect()
-        |
-        LOOKAHEAD(3) select = FromQuery()
+        LOOKAHEAD(3, { !isFromFirstSelectAhead() }) select = FromQuery()
         |
         (
             (
+                LOOKAHEAD({ isFromFirstSelectAhead() }) select = FromFirstSelect()
+                |
+                // DuckDB's TABLE t, also as a set operation operand
+                LOOKAHEAD({ getToken(1).kind == K_TABLE }) select = TableStatement()
+                |
                 LOOKAHEAD(2) select = PivotQuery()
                 |
                 LOOKAHEAD(2) select = UnPivotQuery()
@@ -8141,6 +8151,10 @@ Select SetOperationList(Select select) #SetOperationList: {
         )
 
         (
+            LOOKAHEAD({ getToken(1).kind == K_FROM }) select = FromFirstSelect()
+            |
+            LOOKAHEAD({ getToken(1).kind == K_TABLE }) select = TableStatement()
+            |
             select = PlainSelect()
             |
             select = Values()
@@ -8191,6 +8205,20 @@ Select SetOperationList(Select select) #SetOperationList: {
                 list.setIsolation(ps.getIsolation());
                 ps.setIsolation(null);
             }
+        } else if (selects.get(selects.size() - 1) instanceof TableStatement) {
+            TableStatement table = (TableStatement) selects.get(selects.size() - 1);
+            if (table.getOrderByElements() != null) {
+                list.setOrderByElements(table.getOrderByElements());
+                table.setOrderByElements(null);
+            }
+            if (table.getLimit() != null) {
+                list.setLimit(table.getLimit());
+                table.setLimit(null);
+            }
+            if (table.getOffset() != null) {
+                list.setOffset(table.getOffset());
+                table.setOffset(null);
+            }
         }
         list.setBracketsOpsAndSelects(selects,operations);
         return list;

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

@@ -825,4 +825,28 @@ void testLambdaAsIdentifier() throws JSQLParserException {
         TestUtils.assertSqlCanBeParsedAndDeparsed("ALTER TABLE t DROP COLUMN lambda", true);
         TestUtils.assertSqlCanBeParsedAndDeparsed("ALTER TABLE t RENAME lambda TO x", true);
     }
+
+    @Test
+    void testFromFirstAndTableAsQueryOperands() throws JSQLParserException {
+        for (String sqlStr : new String[] {"SELECT * FROM (FROM t)",
+                "SELECT * FROM (FROM t WHERE a > 1) x JOIN (SELECT 1) y ON true",
+                "SELECT * FROM t WHERE a IN (FROM u)", "SELECT (FROM u SELECT max(a))",
+                "FROM a UNION ALL FROM b", "FROM a WHERE x > 1 UNION ALL SELECT 1",
+                "SELECT 1 EXCEPT FROM b WHERE x", "FROM a SELECT x UNION FROM b SELECT x",
+                "WITH t AS (SELECT 1), u AS (SELECT 2) TABLE t", "TABLE a UNION TABLE b",
+                "SELECT 1 UNION TABLE b", "(TABLE a EXCEPT ALL TABLE b)",
+                "SELECT * FROM TABLE(f(1))"}) {
+            TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+        }
+
+        SetOperationList union = (SetOperationList) CCJSqlParserUtil
+                .parse("TABLE a UNION TABLE b ORDER BY 1 LIMIT 2");
+        Assertions.assertEquals("1", union.getOrderByElements().get(0).toString());
+        Assertions.assertNotNull(union.getLimit());
+        Assertions.assertNull(((TableStatement) union.getSelect(1)).getOrderByElements());
+
+        union = (SetOperationList) CCJSqlParserUtil.parse("FROM a UNION FROM b ORDER BY 1");
+        Assertions.assertTrue(((PlainSelect) union.getSelect(0)).isFromFirst());
+        Assertions.assertEquals("1", union.getOrderByElements().get(0).toString());
+    }
 }