feat: Fix GROUP_CONCAT SEPARATOR to accept expressions, not just string literals

The MySQLGroupConcat production hardcoded SEPARATOR <S_CHAR_LITERAL>,
causing GROUP_CONCAT(col SEPARATOR CHR(10)) and similar to fail.

Replace the dedicated MySQLGroupConcat production with a generic
(KEYWORD expr)* tail in InternalFunction that captures dialect-specific
keyword-expression pairs like SEPARATOR after the standard clauses.
This routes GROUP_CONCAT through InternalFunction like any other function.

- New: isKeywordArgumentAhead() semantic lookahead with 3-layer filter
- New: KeywordArgumentName() BNF production (RelObjectName + K_USING)
- New: Function.KeywordArgument inner class + List<KeywordArgument> on Function
- New: keywordArguments support in AnalyticExpression and ExpressionDeParser
- Removed: MySQLGroupConcat grammar production (absorbed by InternalFunction)

Signed-off-by: Andreas Reichel <andreas@manticore-projects.com>
Signed-off-by: manticore-projects <andreas@manticore-projects.com>

Author: manticore-projects

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

@@ -52,6 +52,8 @@ public class AnalyticExpression extends ASTNodeAccessImpl implements Expression
 
     private Limit limit = null;
 
+    private List<Function.KeywordArgument> keywordArguments = null;
+
     public AnalyticExpression() {}
 
     public AnalyticExpression(Function function) {
@@ -82,6 +84,7 @@ public AnalyticExpression(Function function) {
         this.onOverflowTruncate = function.getOnOverflowTruncate();
         this.limit = function.getLimit();
         this.keep = function.getKeep();
+        this.keywordArguments = function.getKeywordArguments();
     }
 
 
@@ -263,6 +266,14 @@ public AnalyticExpression setLimit(Limit limit) {
         return this;
     }
 
+    public List<Function.KeywordArgument> getKeywordArguments() {
+        return keywordArguments;
+    }
+
+    public void setKeywordArguments(List<Function.KeywordArgument> keywordArguments) {
+        this.keywordArguments = keywordArguments;
+    }
+
     @Override
     @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.NPathComplexity",
             "PMD.MissingBreakInSwitch"})
@@ -313,6 +324,13 @@ public String toString() {
             b.append(limit);
         }
 
+        // Generic keyword arguments (e.g. SEPARATOR ',')
+        if (keywordArguments != null) {
+            for (Function.KeywordArgument ka : keywordArguments) {
+                ka.appendTo(b);
+            }
+        }
+
         b.append(") ");
         if (keep != null) {
             b.append(keep).append(" ");

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

@@ -16,9 +16,12 @@
 import net.sf.jsqlparser.statement.select.Limit;
 import net.sf.jsqlparser.statement.select.OrderByElement;
 
+import java.io.Serializable;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
+import java.util.Objects;
 
 /**
  * A function as MAX,COUNT...
@@ -43,6 +46,14 @@ public class Function extends ASTNodeAccessImpl implements Expression {
     private String onOverflowTruncate = null;
     private String extraKeyword = null;
 
+    /**
+     * Generic keyword arguments captured inside function parentheses, e.g.
+     * {@code GROUP_CONCAT(col ORDER BY col SEPARATOR ',')} where {@code SEPARATOR ','} is a keyword
+     * argument. This acts as a catch-all for dialect-specific {@code KEYWORD expr} pairs that don't
+     * have dedicated grammar branches.
+     */
+    private List<KeywordArgument> keywordArguments = null;
+
     public Function() {}
 
     public Function(String name, Expression... parameters) {
@@ -281,6 +292,53 @@ public Function setExtraKeyword(String extraKeyword) {
         return this;
     }
 
+    // ── Generic keyword argument support ───────────────────────────────
+
+    /**
+     * Returns the list of generic keyword arguments, e.g. {@code SEPARATOR ','}.
+     *
+     * @return keyword arguments or {@code null}
+     */
+    public List<KeywordArgument> getKeywordArguments() {
+        return keywordArguments;
+    }
+
+    public void setKeywordArguments(List<KeywordArgument> keywordArguments) {
+        this.keywordArguments = keywordArguments;
+    }
+
+    /**
+     * Adds a single keyword argument (appends to the list, creating it if needed).
+     */
+    public Function addKeywordArgument(String keyword, Expression expression) {
+        if (this.keywordArguments == null) {
+            this.keywordArguments = new ArrayList<>();
+        }
+        this.keywordArguments.add(new KeywordArgument(keyword, expression));
+        return this;
+    }
+
+    public Function withKeywordArguments(List<KeywordArgument> keywordArguments) {
+        this.keywordArguments = keywordArguments;
+        return this;
+    }
+
+    /**
+     * Convenience lookup: returns the expression for the first keyword argument matching the given
+     * keyword (case-insensitive), or {@code null}.
+     */
+    public Expression getKeywordArgumentValue(String keyword) {
+        if (keywordArguments == null) {
+            return null;
+        }
+        for (KeywordArgument ka : keywordArguments) {
+            if (ka.getKeyword().equalsIgnoreCase(keyword)) {
+                return ka.getExpression();
+            }
+        }
+        return null;
+    }
+
     @Override
     @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.NPathComplexity"})
     public String toString() {
@@ -339,6 +397,13 @@ public String toString() {
                     b.append(" ON OVERFLOW ").append(onOverflowTruncate);
                 }
 
+                // Generic keyword arguments (e.g. SEPARATOR ',')
+                if (keywordArguments != null) {
+                    for (KeywordArgument ka : keywordArguments) {
+                        ka.appendTo(b);
+                    }
+                }
+
                 b.append(")");
                 params = b.toString();
             } else {
@@ -462,6 +527,74 @@ public enum NullHandling {
         IGNORE_NULLS, RESPECT_NULLS;
     }
 
+    // ── KeywordArgument inner class ────────────────────────────────────
+
+    /**
+     * Represents a generic {@code KEYWORD expression} pair inside a function call.
+     * <p>
+     * Examples:
+     * <ul>
+     * <li>{@code GROUP_CONCAT(col SEPARATOR ',')} → keyword="SEPARATOR", expression=','</li>
+     * </ul>
+     */
+    public static class KeywordArgument implements Serializable {
+        private String keyword;
+        private Expression expression;
+
+        public KeywordArgument() {}
+
+        public KeywordArgument(String keyword, Expression expression) {
+            this.keyword = keyword;
+            this.expression = expression;
+        }
+
+        public String getKeyword() {
+            return keyword;
+        }
+
+        public KeywordArgument setKeyword(String keyword) {
+            this.keyword = keyword;
+            return this;
+        }
+
+        public Expression getExpression() {
+            return expression;
+        }
+
+        public KeywordArgument setExpression(Expression expression) {
+            this.expression = expression;
+            return this;
+        }
+
+        public StringBuilder appendTo(StringBuilder builder) {
+            builder.append(" ").append(keyword).append(" ").append(expression);
+            return builder;
+        }
+
+        @Override
+        public String toString() {
+            return keyword + " " + expression;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) {
+                return true;
+            }
+            if (!(o instanceof KeywordArgument)) {
+                return false;
+            }
+            KeywordArgument that = (KeywordArgument) o;
+            return Objects.equals(keyword, that.keyword)
+                    && Objects.equals(expression, that.expression);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(keyword, expression);
+        }
+    }
+
     public static class HavingClause extends ASTNodeAccessImpl implements Expression {
         HavingType havingType;
         Expression expression;

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

@@ -917,6 +917,15 @@ public <S> StringBuilder visit(Function function, S context) {
             if (function.getLimit() != null) {
                 new LimitDeparser(this, builder).deParse(function.getLimit());
             }
+
+            // Generic keyword arguments (e.g. SEPARATOR ',', USING utf8)
+            if (function.getKeywordArguments() != null) {
+                for (Function.KeywordArgument ka : function.getKeywordArguments()) {
+                    builder.append(" ").append(ka.getKeyword()).append(" ");
+                    ka.getExpression().accept(this, context);
+                }
+            }
+
             builder.append(")");
         }