Keep columns named table and print every clause of TABLE t

- `(TABLE` starts a sub-select only when a table name follows and then
  the end of the query, so `(table = 'hits')` and `(table)` stay
  expressions on a column named table. `FROM (TABLE s.t) x` now parses.
- A parenthesized `FROM t` without clauses stays a `FromQuery`.
- `TableStatement` uses `Select.appendTo`, and its deparser prints
  OPTION, FETCH and the isolation level, so `TABLE t FETCH FIRST 1 ROWS
  ONLY` keeps its FETCH.
- `CREATE TABLE ... AS` takes any query, including `TABLE a UNION TABLE b`.

Author: guizmaii

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

@@ -34,29 +34,6 @@ public StringBuilder appendSelectBodyTo(StringBuilder builder) {
         return 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));
-
-        if (limit != null) {
-            builder.append(limit);
-        }
-        if (offset != null) {
-            builder.append(offset);
-        }
-        return builder;
-    }
-
     @Override
     public <T, S> T accept(SelectVisitor<T> selectVisitor, S context) {
         return selectVisitor.visit(this, context);

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

@@ -104,12 +104,21 @@ public <S> StringBuilder visit(TableStatement tableStatement, S context) {
                     .deParse(tableStatement.getOrderByElements());
         }
 
+        if (tableStatement.getOption() != null) {
+            builder.append(tableStatement.getOption());
+        }
         if (tableStatement.getLimit() != null) {
             new LimitDeparser(expressionVisitor, builder).deParse(tableStatement.getLimit());
         }
         if (tableStatement.getOffset() != null) {
             deparse(tableStatement.getOffset());
         }
+        if (tableStatement.getFetch() != null) {
+            builder.append(tableStatement.getFetch());
+        }
+        if (tableStatement.getIsolation() != null) {
+            builder.append(tableStatement.getIsolation());
+        }
 
         // TODO UNION
 

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

@@ -746,6 +746,7 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
             // ( 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 || k2 == K_FROM) return false;
+            if (k2 == K_TABLE && isTableQueryAhead(2)) return false;
             // ( ( SELECT ) UNION ( SELECT ) ) → isNestedSetOperationAhead handles it
             // Other (( patterns: ( (SELECT...) JOIN ... ) or ( (table) ) → ParenthesedFromItem
             if (k2 == K_LATERAL) return false; // handled by LateralSubSelect
@@ -777,13 +778,35 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
         } catch (TokenMgrException e) { return false; }
     }
 
+    /**
+     * Whether the TABLE at {@code offset} starts DuckDB's TABLE t query rather than naming a
+     * column, as in (table = 'x'): a table name follows, and then the end of the query.
+     */
+    private boolean isTableQueryAhead(int offset) {
+        Token token = getToken(offset);
+        do {
+            token = nextWithItemToken(token);
+            if (!isIdentifierishNameToken(token)) {
+                return false;
+            }
+            token = nextWithItemToken(token);
+        } while (".".equals(token.image));
+        switch (token.kind) {
+            case CLOSING_BRACKET: case K_UNION: case K_EXCEPT: case K_INTERSECT: case K_MINUS:
+            case K_ORDER: case K_LIMIT: case K_OFFSET: case K_FETCH:
+                return true;
+            default:
+                return false;
+        }
+    }
+
     protected boolean isParenthesedSelectAhead() {
         try {
             if (getToken(1).kind != OPENING_BRACKET) return false;
             int k = getToken(2).kind;
-            // DuckDB's (FROM t ...) and (TABLE t), but not a TABLE(...) function
+            // DuckDB's (FROM t ...) and (TABLE t ...)
             return k == K_SELECT || k == K_WITH || k == K_VALUES || k == K_FROM
-                    || k == K_TABLE && getToken(3).kind != OPENING_BRACKET;
+                    || k == K_TABLE && isTableQueryAhead(2);
         } catch (TokenMgrException e) {
             return false;
         }
@@ -1408,9 +1431,9 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
             if ("(".equals(token.image)) {
                 depth++;
             } else if (")".equals(token.image)) {
-                // the end of the parenthesized query this FROM starts, e.g. (FROM t)
+                // the end of the parenthesized query this FROM starts
                 if (--depth < 0) {
-                    return true;
+                    return false;
                 }
             } else if (depth == 0) {
                 switch (token.kind) {
@@ -15849,7 +15872,7 @@ CreateTable CreateTable(boolean isUsingOrReplace):
                 createTable.setExecute(execute);
             }
             |
-            ( LOOKAHEAD(<K_TABLE>) select=TableStatement() | select=Select() )
+            select=Select()
             { createTable.setSelect(select, false); }
         )
         [ LOOKAHEAD(2) <K_WITH> withData=DataPopulation()

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

@@ -849,4 +849,20 @@ void testFromFirstAndTableAsQueryOperands() throws JSQLParserException {
         Assertions.assertTrue(((PlainSelect) union.getSelect(0)).isFromFirst());
         Assertions.assertEquals("1", union.getOrderByElements().get(0).toString());
     }
+
+    @Test
+    void testTableQueryKeepsTableColumnsAndTrailingClauses() throws JSQLParserException {
+        // TABLE also names columns, e.g. in ClickHouse's system.parts
+        for (String sqlStr : new String[] {
+                "SELECT database, table FROM system.parts WHERE (database = 'default') AND (table = 'hits')",
+                "SELECT (table), (table.a), (table + 1) FROM t",
+                "SELECT a FROM t WHERE (table, b) IN ((1, 2))",
+                "SELECT * FROM (TABLE s.t) x", "TABLE t FETCH FIRST 1 ROWS ONLY",
+                "WITH a AS (SELECT 1) TABLE a FETCH FIRST 1 ROWS ONLY",
+                "CREATE TABLE x AS TABLE a UNION TABLE b"}) {
+            TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+        }
+        Assertions.assertInstanceOf(net.sf.jsqlparser.statement.piped.FromQuery.class,
+                ((ParenthesedSelect) CCJSqlParserUtil.parse("(FROM t)")).getSelect());
+    }
 }