Merge master and keep PostgreSQL replication DDL independently mergeable

Author: minleejae

.github/workflows/ci.yml

@@ -64,8 +64,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        # windows-latest disabled: see #<issue> — record the reason, not just the comment
-        os: [ ubuntu-latest, macos-latest ]
+        os: [ ubuntu-latest, windows-latest, macos-latest ]
     steps:
       - uses: actions/checkout@v5
         with:

.mvn/jvm.config

@@ -0,0 +1 @@
+-Dfile.encoding=UTF-8

pom.xml

@@ -426,6 +426,11 @@
                         <goals>
                             <goal>jjtree-javacc</goal>
                         </goals>
+                        <!--
+                            GRAMMAR_ENCODING governs reading only: JJTree writes the intermediate
+                            .jj with the JVM default charset, which mangles the grammar's non-ASCII
+                            character classes unless file.encoding is UTF-8 (see .mvn/jvm.config).
+                        -->
                         <configuration>
                             <javaccCmdLineArgs>
                                 <arg>-CODE_GENERATOR:"Java"</arg>
@@ -564,11 +569,13 @@
                         @{jacocoArgLine} is resolved late, after jacoco:prepare-agent has run.
                         Without it the JaCoCo agent would be dropped and coverage reports empty.
                     -->
+                    <!-- Forked test JVMs do not inherit .mvn/jvm.config, so pin the encoding here too. -->
                     <argLine>
                         @{jacocoArgLine}
                         --add-opens=java.base/java.lang=ALL-UNNAMED
                         --add-opens=java.base/java.util=ALL-UNNAMED
                         -Xmx2G -Xms800m -Xss4m
+                        -Dfile.encoding=UTF-8
                     </argLine>
                 </configuration>
             </plugin>

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

@@ -713,13 +713,7 @@ public <S> T visit(VariableAssignment variableAssignment, S context) {
 
     @Override
     public <S> T visit(XMLSerializeExpr xmlSerializeExpr, S context) {
-        ArrayList<Expression> subExpressions = new ArrayList<>();
-
-        subExpressions.add(xmlSerializeExpr.getExpression());
-        for (OrderByElement orderByElement : xmlSerializeExpr.getOrderByElements()) {
-            subExpressions.add(orderByElement.getExpression());
-        }
-        return visitExpressions(xmlSerializeExpr, context, subExpressions);
+        return visitExpressions(xmlSerializeExpr, context, xmlSerializeExpr.getExpressions());
     }
 
     @Override

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

@@ -9,7 +9,9 @@
  */
 package net.sf.jsqlparser.expression;
 
+import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Consumer;
 
 import static java.util.stream.Collectors.joining;
 
@@ -19,9 +21,19 @@
 
 public class XMLSerializeExpr extends ASTNodeAccessImpl implements Expression {
 
+    public enum SerializationMode {
+        CONTENT, DOCUMENT
+    }
+
     private Expression expression;
     private List<OrderByElement> orderByElements;
     private ColDataType dataType;
+    private SerializationMode serializationMode;
+    private StringValue encoding;
+    private StringValue version;
+    private Boolean indent;
+    private LongValue indentSize;
+    private Boolean showDefaults;
 
     @Override
     public <T, S> T accept(ExpressionVisitor<T> expressionVisitor, S context) {
@@ -52,11 +64,141 @@ public void setDataType(ColDataType dataType) {
         this.dataType = dataType;
     }
 
+    /** Null retains the legacy XMLAGG(XMLTEXT(...)) form and its existing expression getter. */
+    public SerializationMode getSerializationMode() {
+        return serializationMode;
+    }
+
+    public void setSerializationMode(SerializationMode serializationMode) {
+        this.serializationMode = serializationMode;
+    }
+
+    public StringValue getEncoding() {
+        return encoding;
+    }
+
+    public void setEncoding(StringValue encoding) {
+        this.encoding = encoding;
+    }
+
+    public StringValue getVersion() {
+        return version;
+    }
+
+    public void setVersion(StringValue version) {
+        this.version = version;
+    }
+
+    /** Null preserves omission, true is INDENT, and false is NO INDENT. */
+    public Boolean getIndent() {
+        return indent;
+    }
+
+    public void setIndent(Boolean indent) {
+        this.indent = indent;
+    }
+
+    public LongValue getIndentSize() {
+        return indentSize;
+    }
+
+    public void setIndentSize(LongValue indentSize) {
+        this.indentSize = indentSize;
+    }
+
+    /** Null preserves omission, true is SHOW DEFAULTS, and false is HIDE DEFAULTS. */
+    public Boolean getShowDefaults() {
+        return showDefaults;
+    }
+
+    public void setShowDefaults(Boolean showDefaults) {
+        this.showDefaults = showDefaults;
+    }
+
+    /** Shared child discovery for expression, table-name and validation visitors. */
+    public List<Expression> getExpressions() {
+        List<Expression> result = new ArrayList<>();
+        if (expression != null) {
+            result.add(expression);
+        }
+        if (orderByElements != null) {
+            for (OrderByElement orderBy : orderByElements) {
+                result.add(orderBy.getExpression());
+            }
+        }
+        if (encoding != null) {
+            result.add(encoding);
+        }
+        if (version != null) {
+            result.add(version);
+        }
+        if (indentSize != null) {
+            result.add(indentSize);
+        }
+        return result;
+    }
+
+    /** Render both forms without bypassing custom expression or ORDER BY deparsers. */
+    public StringBuilder appendTo(StringBuilder sql, Consumer<Expression> expressionWriter,
+            Consumer<List<OrderByElement>> orderByWriter) {
+        validateOptions();
+        sql.append("xmlserialize(");
+        if (serializationMode == null) {
+            sql.append("xmlagg(xmltext(");
+            expressionWriter.accept(expression);
+            sql.append(")");
+            if (orderByElements != null) {
+                orderByWriter.accept(orderByElements);
+            }
+            sql.append(") AS ").append(dataType);
+        } else {
+            sql.append(serializationMode).append(" ");
+            expressionWriter.accept(expression);
+            if (dataType != null) {
+                sql.append(" AS ").append(dataType);
+            }
+            if (encoding != null) {
+                sql.append(" ENCODING ");
+                expressionWriter.accept(encoding);
+            }
+            if (version != null) {
+                sql.append(" VERSION ");
+                expressionWriter.accept(version);
+            }
+            if (indent != null) {
+                sql.append(indent ? " INDENT" : " NO INDENT");
+                if (indent && indentSize != null) {
+                    sql.append(" SIZE = ");
+                    expressionWriter.accept(indentSize);
+                }
+            }
+            if (showDefaults != null) {
+                sql.append(showDefaults ? " SHOW DEFAULTS" : " HIDE DEFAULTS");
+            }
+        }
+        return sql.append(")");
+    }
+
+    public void validateOptions() {
+        if (indentSize != null && (!Boolean.TRUE.equals(indent) || indentSize.getValue() < 0)) {
+            throw new IllegalArgumentException(
+                    "An indentation size requires INDENT and must be nonnegative");
+        }
+        if (serializationMode == null && (encoding != null || version != null || indent != null
+                || indentSize != null || showDefaults != null)) {
+            throw new IllegalArgumentException("Serialization options require CONTENT or DOCUMENT");
+        }
+        if (serializationMode != null && orderByElements != null && !orderByElements.isEmpty()) {
+            throw new IllegalArgumentException(
+                    "ORDER BY belongs inside the serialized XMLAGG expression");
+        }
+    }
+
     @Override
     public String toString() {
-        return "xmlserialize(xmlagg(xmltext(" + expression + ")"
-                + (orderByElements != null ? " ORDER BY " + orderByElements.stream()
-                        .map(OrderByElement::toString).collect(joining(", ")) : "")
-                + ") AS " + dataType + ")";
+        StringBuilder sql = new StringBuilder();
+        return appendTo(sql, sql::append, orderBy -> sql.append(" ORDER BY ")
+                .append(orderBy.stream().map(OrderByElement::toString).collect(joining(", "))))
+                .toString();
     }
 }

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

@@ -561,6 +561,10 @@ public enum Feature {
     createSequence,
     /** Publication and subscription definitions. */
     createPublication, alterPublication, createSubscription, alterSubscription,
+    /**
+     * Structured type, domain and extension statements.
+     */
+    createType, alterType, createDomain, alterDomain, createExtension, alterExtension,
     /**
      * SQL "CREATE SYNONYM" statement is allowed
      *

src/main/java/net/sf/jsqlparser/statement/ExplainStatement.java

@@ -10,10 +10,10 @@
 package net.sf.jsqlparser.statement;
 
 import java.io.Serializable;
+import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Locale;
-import java.util.stream.Collectors;
 import net.sf.jsqlparser.schema.Table;
 
 /**
@@ -22,7 +22,8 @@
 public class ExplainStatement implements Statement {
     private String keyword;
     private Statement statement;
-    private LinkedHashMap<OptionType, Option> options;
+    private List<Option> options = new ArrayList<>();
+    private boolean parenthesizedOptions;
     private Table table;
 
     public ExplainStatement(String keyword) {
@@ -42,7 +43,7 @@ public ExplainStatement(String keyword, Statement statement, List<Option> option
         this.keyword = keyword;
         setStatement(statement);
 
-        initializeOptions(optionList);
+        setOptionList(optionList);
     }
 
     public ExplainStatement(Statement statement) {
@@ -72,29 +73,59 @@ public ExplainStatement setStatement(Statement statement) {
     }
 
     public LinkedHashMap<OptionType, Option> getOptions() {
-        return options == null ? null : new LinkedHashMap<>(options);
+        if (options.isEmpty()) {
+            return null;
+        }
+        LinkedHashMap<OptionType, Option> result = new LinkedHashMap<>();
+        for (Option option : options) {
+            result.put(option.getType(), option);
+        }
+        return result;
+    }
+
+    /** Ordered options, including repetitions; the returned list is a defensive copy. */
+    public List<Option> getOptionList() {
+        return new ArrayList<>(options);
     }
 
+    public void setOptionList(List<Option> optionList) {
+        options = optionList == null ? new ArrayList<>() : new ArrayList<>(optionList);
+    }
+
+    public boolean isParenthesizedOptions() {
+        return parenthesizedOptions;
+    }
+
+    public ExplainStatement setParenthesizedOptions(boolean parenthesizedOptions) {
+        this.parenthesizedOptions = parenthesizedOptions;
+        return this;
+    }
+
+    /** Adds an option, or replaces the last existing option of the same type. */
     public void addOption(Option option) {
-        if (options == null) {
-            options = new LinkedHashMap<>();
+        for (int i = options.size() - 1; i >= 0; i--) {
+            if (options.get(i).getType() == option.getType()) {
+                options.set(i, option);
+                return;
+            }
         }
-
-        options.put(option.getType(), option);
+        options.add(option);
     }
 
     /**
-     * Returns the first option that matches this optionType
+     * Returns the last option that matches this optionType.
      *
      * @param optionType the option type to retrieve an Option for
-     * @return an option of that type, or null. In case of duplicate options, the first found option
+     * @return an option of that type, or null. In case of duplicate options, the last found option
      *         will be returned.
      */
     public Option getOption(OptionType optionType) {
-        if (options == null) {
-            return null;
+        for (int i = options.size() - 1; i >= 0; i--) {
+            if (options.get(i).getType() == optionType) {
+                return options.get(i);
+            }
         }
-        return options.get(optionType);
+        return null;
     }
 
     public String getKeyword() {
@@ -112,12 +143,7 @@ public String toString() {
         if (table != null) {
             builder.append(" ").append(table);
         } else {
-            if (options != null) {
-                builder.append(" ");
-                builder.append(options.values().stream().map(Option::formatOption)
-                        .collect(Collectors.joining(" ")));
-            }
-
+            appendOptionsTo(builder);
             builder.append(" ");
             if (statement != null) {
                 builder.append(statement);
@@ -132,17 +158,25 @@ public <T, S> T accept(StatementVisitor<T> statementVisitor, S context) {
         return statementVisitor.visit(this, context);
     }
 
-    private void initializeOptions(List<Option> optionList) {
-        if (optionList != null && !optionList.isEmpty()) {
-            options = new LinkedHashMap<>();
-            for (Option o : optionList) {
-                options.put(o.getType(), o);
+    /** Shared by SQL rendering and statement deparsers; includes the leading separator. */
+    public StringBuilder appendOptionsTo(StringBuilder builder) {
+        if (!options.isEmpty()) {
+            builder.append(parenthesizedOptions ? " (" : " ");
+            for (int i = 0; i < options.size(); i++) {
+                if (i > 0) {
+                    builder.append(parenthesizedOptions ? ", " : " ");
+                }
+                builder.append(options.get(i).formatOption());
+            }
+            if (parenthesizedOptions) {
+                builder.append(")");
             }
         }
+        return builder;
     }
 
     public enum OptionType {
-        ANALYZE, VERBOSE, COSTS, BUFFERS, FORMAT, PLAN, PLAN_FOR;
+        ANALYZE, VERBOSE, COSTS, BUFFERS, FORMAT, PLAN, PLAN_FOR, TIMING, SUMMARY, SETTINGS, WAL, GENERIC_PLAN, SERIALIZE, MEMORY;
 
         public static OptionType from(String type) {
             return Enum.valueOf(OptionType.class, type.toUpperCase(Locale.ROOT));
@@ -171,7 +205,7 @@ public void setValue(String value) {
         }
 
         public String formatOption() {
-            return type.name().replace("_", " ") + (value != null
+            return (type == OptionType.PLAN_FOR ? "PLAN FOR" : type.name()) + (value != null
                     ? " " + value
                     : "");
         }