Merge master and preserve CYCLE and DML CTE validation

Author: minleejae

CHANGELOG.md

@@ -2,29 +2,6 @@
 
 Changelog of JSqlParser.
 
-## jsqlparser-5.4 (2025-05-25)
-
-### Features
-
--  Session Statement ([7d2e6](https://github.com/JSQLParser/JSqlParser/commit/7d2e6b65324ce57) manticore-projects)
--  sync with Master ([e14d7](https://github.com/JSQLParser/JSqlParser/commit/e14d7eb1c4e9963) manticore-projects)
--  JavaCC 8 keyword utils ([cfe2d](https://github.com/JSQLParser/JSqlParser/commit/cfe2d8ccaf7c76d) manticore-projects)
--  Complete on JavaCC-8 ([1b7ed](https://github.com/JSQLParser/JSqlParser/commit/1b7ed2d7be000ce) manticore-projects)
--  Optimise performance ([e91c4](https://github.com/JSQLParser/JSqlParser/commit/e91c480b0bbe0a9) manticore-projects)
--  avoid looping through the tokens every single time ([b18fb](https://github.com/JSQLParser/JSqlParser/commit/b18fbca1f48e63e) manticore-projects)
--  avoid looping through the tokens every single time ([7ac6c](https://github.com/JSQLParser/JSqlParser/commit/7ac6cd0fa08d713) manticore-projects)
--  add proper JMH benchmarks ([21c98](https://github.com/JSQLParser/JSqlParser/commit/21c983fc1f4f3f2) manticore-projects)
--  JavaCC-8 ([9d144](https://github.com/JSQLParser/JSqlParser/commit/9d1442e9a4800e2) manticore-projects)
--  remove all semantic lookaheads ([5abca](https://github.com/JSQLParser/JSqlParser/commit/5abcaeaede27cfe) manticore-projects)
-
-### Bug Fixes
-
--  bring back `SYNTACTIC LOOKAHEAD` where it makes sense ([b3c5b](https://github.com/JSQLParser/JSqlParser/commit/b3c5b63344de193) manticore-projects)
--  the Quotes Token manipulation ([bad81](https://github.com/JSQLParser/JSqlParser/commit/bad818e0b872c6a) manticore-projects)
-
-### Other changes
-
-
 ## jsqlparser-5.3 (2025-05-17)
 
 ### Features

README.md

@@ -138,16 +138,23 @@ and missing syntax gets added on demand — [open an issue](https://github.com/J
 |  | Statements |
 |---|---|
 | **Queries** | `SELECT` · `WITH …` · Piped SQL |
+| **ksqlDB windows** | JOIN `WITHIN`, window `GRACE PERIOD`, and `EMIT CHANGES`/`FINAL` |
 | **DML** | `INSERT` · `UPDATE` · `UPSERT` · `MERGE` · `DELETE` · `TRUNCATE TABLE` |
 | **DDL** | `CREATE …` · `ALTER …` · `DROP …` |
 | **PostgreSQL RLS** | `CREATE POLICY` · `ALTER TABLE … ENABLE`/`DISABLE`/`FORCE`/`NO FORCE ROW LEVEL SECURITY` |
+| **Informix constraints** | `ALTER TABLE … ADD CONSTRAINT` with trailing constraint names for primary, unique, foreign and check constraints; enable with `parser.withDialect(Dialect.INFORMIX)` |
 | **Salesforce SOQL** | `INCLUDES` · `EXCLUDES` |
 
 Beyond statement shapes, the grammar handles nested sub-selects, bind parameters (`?`,
 `:name`), window and analytic functions, Oracle hints, and the T-SQL square-bracket versus
 array-literal ambiguity. The complete reference is on the
 [syntax page](https://jsqlparser.github.io/JSqlParser/syntax.html).
 
+PostgreSQL dollar-quoted strings, including `$tag$…$tag$`, retain their delimiter and
+literal body in `StringValue`. Tagged quotes are disabled by default to preserve
+identifier parsing. Enable them with `parser.withDialect(Dialect.POSTGRESQL)` or
+`parser.withDollarQuotedStringTags(true)`. Untagged `$$…$$` literals remain enabled.
+
 ## Statement classification
 
 Any parsed statement can say what it actually does — no second parse, no visitor to write:

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

@@ -58,7 +58,7 @@ public class AnalyticExpression extends ASTNodeAccessImpl implements Expression
     public AnalyticExpression() {}
 
     public AnalyticExpression(Function function) {
-        this.name = String.join(" ", function.getMultipartName());
+        this.name = function.getName();
         this.allColumns = function.isAllColumns();
         this.distinct = function.isDistinct();
         this.unique = function.isUnique();

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

@@ -10,6 +10,7 @@
 package net.sf.jsqlparser.expression;
 
 import java.util.List;
+import net.sf.jsqlparser.statement.execute.ExecuteArgument;
 import net.sf.jsqlparser.expression.operators.arithmetic.Addition;
 import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseAnd;
 import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseLeftShift;
@@ -72,6 +73,10 @@
 
 public interface ExpressionVisitor<T> {
 
+    default <S> T visit(ExecuteArgument argument, S context) {
+        return argument.getExpression().accept(this, context);
+    }
+
     default <S> T visitExpressions(ExpressionList<? extends Expression> expressions, S context) {
         if (expressions != null) {
             expressions.forEach(expression -> expression.accept(this, context));

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

@@ -12,8 +12,8 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import net.sf.jsqlparser.expression.operators.arithmetic.Addition;
 import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseAnd;
 import net.sf.jsqlparser.expression.operators.arithmetic.BitwiseLeftShift;
@@ -119,11 +119,9 @@ public <S> T visit(Function function, S context) {
         if (function.getKeep() != null) {
             subExpressions.add(function.getKeep());
         }
-        if (function.getOrderByElements() != null) {
-            for (OrderByElement orderByElement : function.getOrderByElements()) {
-                subExpressions.add(orderByElement.getExpression());
-            }
-        }
+        addOrderByExpressions(subExpressions, function.getOrderByElements());
+        addFunctionModifiers(subExpressions, function.getHavingClause(),
+                function.getKeywordArguments(), function.getLimit());
         return visitExpressions(function, context, subExpressions);
     }
 
@@ -419,29 +417,41 @@ public <S> T visit(AnalyticExpression analyticExpression, S context) {
         if (analyticExpression.getKeep() != null) {
             subExpressions.add(analyticExpression.getKeep());
         }
-        if (analyticExpression.getFuncOrderBy() != null) {
-            for (OrderByElement element : analyticExpression.getOrderByElements()) {
-                subExpressions.add(element.getExpression());
+        subExpressions.add(analyticExpression.getFilterExpression());
+        addOrderByExpressions(subExpressions, analyticExpression.getFuncOrderBy());
+        addFunctionModifiers(subExpressions, analyticExpression.getHavingClause(),
+                analyticExpression.getKeywordArguments(), analyticExpression.getLimit());
+        if (analyticExpression.getWindowDefinition() != null) {
+            subExpressions.addAll(analyticExpression.getWindowDefinition().getAllExpressions());
+        }
+        return visitExpressions(analyticExpression, context, subExpressions);
+    }
+
+    private static void addOrderByExpressions(List<Expression> expressions,
+            List<OrderByElement> orderBy) {
+        if (orderBy != null) {
+            for (OrderByElement element : orderBy) {
+                expressions.add(element.getExpression());
             }
         }
-        if (analyticExpression.getWindowElement() != null) {
-            /*
-             * Visit expressions from the range and offset of the window element. Do this using
-             * optional chains, because several things down the tree can be null e.g. the
-             * expression. So, null-safe versions of e.g.:
-             * analyticExpression.getWindowElement().getOffset().getExpression().accept(this,
-             * parameters);
-             */
-            Optional.ofNullable(analyticExpression.getWindowElement().getRange())
-                    .map(WindowRange::getStart)
-                    .map(WindowOffset::getExpression).ifPresent(subExpressions::add);
-            Optional.ofNullable(analyticExpression.getWindowElement().getRange())
-                    .map(WindowRange::getEnd)
-                    .map(WindowOffset::getExpression).ifPresent(subExpressions::add);
-            Optional.ofNullable(analyticExpression.getWindowElement().getOffset())
-                    .map(WindowOffset::getExpression).ifPresent(subExpressions::add);
+    }
+
+    private static void addFunctionModifiers(List<Expression> expressions,
+            Function.HavingClause having, List<Function.KeywordArgument> arguments,
+            net.sf.jsqlparser.statement.select.Limit limit) {
+        expressions.add(having);
+        if (arguments != null) {
+            for (Function.KeywordArgument argument : arguments) {
+                expressions.add(argument.getExpression());
+            }
+        }
+        if (limit != null) {
+            expressions.add(limit.getOffset());
+            expressions.add(limit.getRowCount());
+            if (limit.getByExpressions() != null) {
+                expressions.addAll(limit.getByExpressions());
+            }
         }
-        return visitExpressions(analyticExpression, context, subExpressions);
     }
 
     @Override

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

@@ -42,10 +42,14 @@ public StringValue(String escapedValue) {
             value = escapedValue.substring(1, escapedValue.length() - 1);
             quoteStr = "\"";
             return;
-        } else if (escapedValue.length() >= 4 && escapedValue.startsWith("$$")
-                && escapedValue.endsWith("$$")) {
-            value = escapedValue.substring(2, escapedValue.length() - 2);
-            quoteStr = "$$";
+        }
+
+        String delimiter = getDollarQuoteDelimiter(escapedValue);
+        if (delimiter != null && escapedValue.length() >= 2 * delimiter.length()
+                && escapedValue.endsWith(delimiter)) {
+            quoteStr = delimiter;
+            value = escapedValue.substring(delimiter.length(),
+                    escapedValue.length() - delimiter.length());
             return;
         }
 
@@ -64,6 +68,32 @@ public StringValue(String escapedValue) {
         value = escapedValue;
     }
 
+    /**
+     * Returns the opening PostgreSQL dollar-quote delimiter, or null if there is none. A tag
+     * follows unquoted identifier rules, excluding dollar signs. This method does not require the
+     * closing delimiter or inspect the body.
+     */
+    public static String getDollarQuoteDelimiter(String text) {
+        if (text == null || text.length() < 2 || text.charAt(0) != '$') {
+            return null;
+        }
+        int end = text.indexOf('$', 1);
+        if (end < 0) {
+            return null;
+        }
+        for (int i = 1; i < end;) {
+            int character = text.codePointAt(i);
+            boolean valid =
+                    i == 1 ? Character.isUnicodeIdentifierStart(character) || character == '_'
+                            : Character.isUnicodeIdentifierPart(character);
+            if (!valid) {
+                return null;
+            }
+            i += Character.charCount(character);
+        }
+        return text.substring(0, end + 1);
+    }
+
     public String getValue() {
         return value;
     }
@@ -90,6 +120,9 @@ public StringValue setQuoteStr(String quoteStr) {
     }
 
     public String getNotExcapedValue() {
+        if (quoteStr != null && quoteStr.startsWith("$")) {
+            return value;
+        }
         StringBuilder buffer = new StringBuilder(value);
         int index = 0;
         int deletesNum = 0;

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

@@ -10,6 +10,7 @@
 package net.sf.jsqlparser.expression;
 
 import java.io.Serializable;
+import java.util.ArrayList;
 import java.util.List;
 
 import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
@@ -73,6 +74,30 @@ public WindowDefinition withWindowName(String windowName) {
         return this;
     }
 
+    /** Returns the partition, order and frame expressions for both inline and named windows. */
+    public List<Expression> getAllExpressions() {
+        List<Expression> expressions = new ArrayList<>(partitionBy);
+        if (getOrderByElements() != null) {
+            for (OrderByElement element : getOrderByElements()) {
+                expressions.add(element.getExpression());
+            }
+        }
+        if (windowElement != null) {
+            if (windowElement.getRange() != null) {
+                addOffsetExpression(expressions, windowElement.getRange().getStart());
+                addOffsetExpression(expressions, windowElement.getRange().getEnd());
+            }
+            addOffsetExpression(expressions, windowElement.getOffset());
+        }
+        return expressions;
+    }
+
+    private static void addOffsetExpression(List<Expression> expressions, WindowOffset offset) {
+        if (offset != null && offset.getExpression() != null) {
+            expressions.add(offset.getExpression());
+        }
+    }
+
     @Override
     public String toString() {
         StringBuilder b = new StringBuilder();

src/main/java/net/sf/jsqlparser/parser/AbstractJSqlParser.java

@@ -37,15 +37,16 @@ public enum Dialect {
                         Feature.allowHashLineComments,
                         Feature.allowDoubleQuotedStrings), SQLSERVER(AdjacentStringLiterals.OFF,
                                 Feature.allowSquareBracketQuotation), POSTGRESQL(
-                                        AdjacentStringLiterals.NEWLINE), H2, EXASOL, BIGQUERY(
+                                        AdjacentStringLiterals.NEWLINE,
+                                        Feature.allowDollarQuotedStringTags), H2, EXASOL, BIGQUERY(
                                                 AdjacentStringLiterals.WHITESPACE,
                                                 Feature.allowDoubleQuotedStrings,
                                                 Feature.allowHashLineComments,
                                                 Feature.allowBackslashEscapeCharacter), DATABRICKS(
                                                         AdjacentStringLiterals.WHITESPACE,
                                                         Feature.allowDoubleQuotedStrings,
                                                         Feature.allowBackslashEscapeCharacter), SNOWFLAKE(
-                                                                Feature.allowBackslashEscapeCharacter);
+                                                                Feature.allowBackslashEscapeCharacter), INFORMIX;
 
         private final Set<Feature> lexerFeatures;
         private final AdjacentStringLiterals adjacentStringLiterals;
@@ -143,6 +144,14 @@ public P withBackslashEscapeCharacter(boolean allowBackslashEscapeCharacter) {
         return withFeature(Feature.allowBackslashEscapeCharacter, allowBackslashEscapeCharacter);
     }
 
+    /**
+     * Controls tagged dollar quotes; disabled by default, enabled by the PostgreSQL dialect preset.
+     * False preserves dollar-containing identifier spellings.
+     */
+    public P withDollarQuotedStringTags(boolean allowDollarQuotedStringTags) {
+        return withFeature(Feature.allowDollarQuotedStringTags, allowDollarQuotedStringTags);
+    }
+
     public P withDoubleQuotedStrings() {
         return withFeature(Feature.allowDoubleQuotedStrings, true);
     }

src/main/java/net/sf/jsqlparser/parser/CCJSqlParserUtil.java

@@ -429,10 +429,11 @@ public static Statements parseStatements(String sqls, Consumer<CCJSqlParser> con
         }
 
         ExecutorService executorService = Executors.newSingleThreadExecutor();
-        final Statements statements = parseStatements(sqls, executorService, consumer);
-        executorService.shutdown();
-
-        return statements;
+        try {
+            return parseStatements(sqls, executorService, consumer);
+        } finally {
+            executorService.shutdown();
+        }
     }
 
     /**
@@ -447,7 +448,6 @@ public static Statements parseStatements(String sqls, ExecutorService executorSe
             return null;
         }
 
-        Statements statements = null;
         CCJSqlParser parser = newParser(sqls);
         if (consumer != null) {
             consumer.accept(parser);
@@ -457,7 +457,7 @@ public static Statements parseStatements(String sqls, ExecutorService executorSe
 
         // first, try to parse fast and simple
         try {
-            statements = parseStatements(parser.withAllowComplexParsing(false), executorService);
+            return parseStatements(parser.withAllowComplexParsing(false), executorService);
         } catch (JSQLParserException ex) {
             // when fast simple parsing fails, try complex parsing but only if it has a chance to
             // succeed
@@ -468,10 +468,10 @@ public static Statements parseStatements(String sqls, ExecutorService executorSe
                 if (consumer != null) {
                     consumer.accept(parser);
                 }
-                statements = parseStatements(parser.withAllowComplexParsing(true), executorService);
+                return parseStatements(parser.withAllowComplexParsing(true), executorService);
             }
+            throw ex;
         }
-        return statements;
     }
 
     /**

src/main/java/net/sf/jsqlparser/parser/feature/Feature.java

@@ -643,7 +643,7 @@ public enum Feature {
     /**
      * @see Grant
      */
-    grant,
+    grant, revoke, createRole, alterRole, alterDefaultPrivileges,
     /**
      * @see Function
      */
@@ -670,6 +670,9 @@ public enum Feature {
      * @see DeclareStatement
      */
     declare,
+
+    /** SQL Server local table variables in queries and DML targets. */
+    tableVariable,
     /**
      * @see SetStatement
      */
@@ -808,6 +811,12 @@ public enum Feature {
      */
     allowDoubleQuotedStrings(false),
 
+    /**
+     * Recognizes PostgreSQL $tag$...$tag$ literals; disabled by default to preserve unquoted
+     * identifiers, enabled by the PostgreSQL dialect preset. Untagged $$ literals are unaffected.
+     */
+    allowDollarQuotedStringTags(false),
+
     /**
      * concatenates adjacent String Literals: NEWLINE when separated by whitespace with at least one
      * newline (the SQL standard and PostgreSQL), WHITESPACE across any whitespace (GoogleSQL,