Keep stars aliased rename or replace and functions named limit

- Unparenthesized REPLACE needs an AS at the top level of its item, and
  RENAME needs `column AS name` for each item, so `* rename` and
  `* replace` stay aliases of the star.
- `REPLACE (a + 1) AS a` is a single item, as in DuckDB, not a list
  without an alias.
- A comma before `limit(` or `offset(` starts a select item again, and
  `group by` / `order by` right before FROM or the end are a column and
  its alias.
- A transformer with more than one item or column prints parentheses.

Author: guizmaii

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

@@ -183,19 +183,22 @@ public StringBuilder appendTo(StringBuilder builder) {
                         .append(exceptPattern != null ? exceptPattern : exceptColumns);
                 break;
             case EXCLUDE:
-                builder.append("EXCLUDE ")
-                        .append(parenthesized ? exceptColumns : exceptColumns.get(0));
+                builder.append("EXCLUDE ").append(parenthesized || exceptColumns.size() != 1
+                        ? exceptColumns
+                        : exceptColumns.get(0));
                 break;
             case REPLACE:
+                boolean replaceParenthesized = parenthesized || replaceItems.size() != 1;
                 builder.append("REPLACE").append(strict ? " STRICT" : "")
-                        .append(parenthesized ? "(" : " ")
+                        .append(replaceParenthesized ? "(" : " ")
                         .append(Select.getStringList(replaceItems))
-                        .append(parenthesized ? ")" : "");
+                        .append(replaceParenthesized ? ")" : "");
                 break;
             case RENAME:
-                builder.append("RENAME ").append(parenthesized ? "(" : "")
+                boolean renameParenthesized = parenthesized || renameItems.size() != 1;
+                builder.append("RENAME ").append(renameParenthesized ? "(" : "")
                         .append(Select.getStringList(renameItems))
-                        .append(parenthesized ? ")" : "");
+                        .append(renameParenthesized ? ")" : "");
                 break;
             default:
                 throw new IllegalStateException("Unhandled ColumnsTransformerType: " + type);

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

@@ -1675,15 +1675,103 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
             case K_UNION: case K_EXCEPT: case K_INTERSECT: case K_MINUS:
                 return true;
             case K_GROUP: case K_ORDER:
-                return following == K_BY;
+                // not a column named group aliased by: SELECT a, group by FROM t
+                int afterBy = getToken(4).kind;
+                return following == K_BY && afterBy != K_FROM && afterBy != EOF
+                        && afterBy != CLOSING_BRACKET && afterBy != ST_SEMICOLON
+                        && !",".equals(getToken(4).image);
             case K_LIMIT: case K_OFFSET:
-                return following == S_LONG || following == OPENING_BRACKET
-                        || "?".equals(getToken(3).image);
+                return following == S_LONG || "?".equals(getToken(3).image);
             default:
                 return false;
         }
     }
 
+    /**
+     * Whether the REPLACE at {@code offset} is DuckDB's unparenthesized {@code REPLACE expr AS name}:
+     * an AS follows at the top level before the end of the select item, so that a star aliased
+     * "replace" keeps parsing. With {@code offset} 0, the REPLACE has been consumed.
+     */
+    private boolean isUnparenthesizedReplaceAhead(int offset) {
+        Token token = getToken(offset);
+        if (offset > 0 && token.kind != K_REPLACE) {
+            return false;
+        }
+        int depth = 0;
+        while (true) {
+            token = nextWithItemToken(token);
+            if (token.kind == EOF || ";".equals(token.image)) {
+                return false;
+            }
+            if ("(".equals(token.image) || "[".equals(token.image) || "{".equals(token.image)) {
+                depth++;
+            } else if (")".equals(token.image) || "]".equals(token.image)
+                    || "}".equals(token.image)) {
+                if (--depth < 0) {
+                    return false;
+                }
+            } else if (depth == 0) {
+                if (token.kind == K_AS) {
+                    return true;
+                }
+                if (token.kind == K_FROM || ",".equals(token.image)) {
+                    return false;
+                }
+            }
+        }
+    }
+
+    private boolean isUnparenthesizedReplaceAhead() {
+        return isUnparenthesizedReplaceAhead(1);
+    }
+
+    /**
+     * Whether DuckDB's {@code RENAME (column AS name, ...)} or {@code RENAME column AS name}
+     * follows, every column being renamed with AS, so that a star aliased "rename" keeps parsing.
+     */
+    private boolean isRenameAhead() {
+        Token token = getToken(1);
+        if (token.kind != K_RENAME) {
+            return false;
+        }
+        token = nextWithItemToken(token);
+        boolean parenthesized = "(".equals(token.image);
+        if (parenthesized) {
+            token = nextWithItemToken(token);
+        }
+        while (true) {
+            // column [. column]* AS name
+            while (true) {
+                if (!isIdentifierishNameToken(token)) {
+                    return false;
+                }
+                token = nextWithItemToken(token);
+                if (!".".equals(token.image)) {
+                    break;
+                }
+                token = nextWithItemToken(token);
+            }
+            if (token.kind != K_AS) {
+                return false;
+            }
+            token = nextWithItemToken(token);
+            if (!isIdentifierishNameToken(token)) {
+                return false;
+            }
+            token = nextWithItemToken(token);
+            if (!parenthesized) {
+                return true;
+            }
+            if (")".equals(token.image)) {
+                return true;
+            }
+            if (!",".equals(token.image)) {
+                return false;
+            }
+            token = nextWithItemToken(token);
+        }
+    }
+
     /** DuckDB's unparenthesized REPLACE and RENAME name their single item: * RENAME i AS x. */
     private static void requireTransformerAlias(SelectItem<?> item) throws ParseException {
         if (item.getAlias() == null) {
@@ -8667,7 +8755,8 @@ boolean AllColumnsTransformerAhead() #void:
         | <K_EXCLUDE> ParenthesedColumnList() )
       { return true; }
       // DuckDB: * EXCLUDE i, * REPLACE expr AS i, * RENAME [(]i AS x[)]
-    | LOOKAHEAD( <K_EXCLUDE> Column() | <K_REPLACE> | <K_RENAME> ) { return true; }
+    | LOOKAHEAD( <K_EXCLUDE> Column() ) { return true; }
+    | LOOKAHEAD({ isUnparenthesizedReplaceAhead() || isRenameAhead() }) { return true; }
     | { return false; }
 }
 
@@ -8789,7 +8878,8 @@ ColumnsTransformer ColumnsTransformer():
           { transformer = new ColumnsTransformer(ColumnsTransformer.ColumnsTransformerType.REPLACE)
                   .setStrict(strict); }
           (
-              LOOKAHEAD("(") "(" replaceItems = SelectItemsList() ")"
+              LOOKAHEAD({ "(".equals(getToken(1).image) && !isUnparenthesizedReplaceAhead(0) })
+              "(" replaceItems = SelectItemsList() ")"
               |
               item = SelectItem()
               {
@@ -8834,6 +8924,7 @@ AllColumns AllColumns(boolean allowAdditions):
     // BigData allows EXCEPT, DuckDB allows EXCLUDE and RENAME, ClickHouse allows APPLY;
     // they may repeat and combine in any order
     (
+        // AllColumnsTransformerAhead() tells DuckDB's REPLACE and RENAME from an alias of the star
         LOOKAHEAD( <K_APPLY> "(" | <K_REPLACE> | <K_RENAME>
             | <K_EXCEPT> [ <K_STRICT> ] ( ParenthesedColumnList() | <S_CHAR_LITERAL> )
             | <K_EXCLUDE> ( ParenthesedColumnList() | Column() ) )

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

@@ -1007,6 +1007,18 @@ void testStarRenameAndUnparenthesizedModifiers() throws JSQLParserException {
                 net.sf.jsqlparser.expression.ColumnsTransformer.ColumnsTransformerType.RENAME,
                 rename.getType());
         Assertions.assertEquals("i AS x", rename.getRenameItems().get(0).toString());
+
+        // a star aliased rename or replace keeps parsing
+        for (String sqlStr : new String[] {"SELECT * rename FROM t", "SELECT * replace FROM t",
+                "SELECT t.* rename, b FROM t", "SELECT * rename(a, b) FROM t"}) {
+            TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+        }
+        // DuckDB reads a parenthesized expression followed by AS as the single item
+        select = (PlainSelect) CCJSqlParserUtil.parse("SELECT * REPLACE (a + 1) AS a FROM t");
+        Assertions.assertEquals("(a + 1) AS a",
+                ((net.sf.jsqlparser.statement.select.AllColumns) select.getSelectItem(0)
+                        .getExpression()).getTransformers().get(0).getReplaceItems().get(0)
+                        .toString());
     }
 
     @Test
@@ -1019,9 +1031,10 @@ void testTrailingCommaInSelectList() throws JSQLParserException {
                 CCJSqlParserUtil.parse("SELECT 1, LIMIT 1").toString());
         Assertions.assertEquals("SELECT (SELECT 1)",
                 CCJSqlParserUtil.parse("SELECT (SELECT 1,)").toString());
-        // keywords that may name a column still do
-        for (String column : new String[] {"limit", "offset", "group", "order", "qualify"}) {
-            TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT a, " + column + " FROM t", true);
+        // keywords that may name a column or a function still do
+        for (String item : new String[] {"limit", "offset", "group", "order", "qualify",
+                "limit(1)", "offset(1)", "group by", "order by"}) {
+            TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT a, " + item + " FROM t", true);
         }
     }
 }