Merge master and preserve concurrent documentation additions

Author: mj

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

@@ -46,7 +46,7 @@ public enum Dialect {
                                                         AdjacentStringLiterals.WHITESPACE,
                                                         Feature.allowDoubleQuotedStrings,
                                                         Feature.allowBackslashEscapeCharacter), SNOWFLAKE(
-                                                                Feature.allowBackslashEscapeCharacter), INFORMIX, SPANNER, DORIS;
+                                                                Feature.allowBackslashEscapeCharacter), INFORMIX, SPANNER, DORIS, COCKROACHDB;
 
         private final Set<Feature> lexerFeatures;
         private final AdjacentStringLiterals adjacentStringLiterals;

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

@@ -664,6 +664,8 @@ public enum Feature {
      * @see CreateFunctionalStatement
      */
     functionalStatement,
+
+    alterFunction, alterProcedure, createOrAlterRoutine,
     /**
      * SQL block starting with "BEGIN" and ends with "END" statement is allowed
      *

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

@@ -14,6 +14,9 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
+import java.util.function.Consumer;
+import net.sf.jsqlparser.statement.create.function.FunctionReturnType;
+import net.sf.jsqlparser.statement.create.table.TableElement;
 
 /**
  * A base for the declaration of function like statements
@@ -23,6 +26,39 @@ public abstract class CreateFunctionalStatement implements Statement {
     private String kind;
     private boolean orReplace = false;
 
+    public enum Operation {
+        CREATE, ALTER, CREATE_OR_ALTER
+    }
+
+    private Operation operation = Operation.CREATE;
+    private FunctionReturnType returnType;
+    private List<String> routineBodyParts;
+
+    public Operation getOperation() {
+        return operation;
+    }
+
+    public void setOperation(Operation operation) {
+        this.operation = operation;
+    }
+
+    public FunctionReturnType getReturnType() {
+        return returnType;
+    }
+
+    public void setReturnType(FunctionReturnType returnType) {
+        this.returnType = returnType;
+    }
+
+    public List<String> getRoutineBodyParts() {
+        return routineBodyParts;
+    }
+
+    public void setRoutineBodyParts(List<String> parts) {
+        routineBodyParts = parts;
+    }
+
+
     private List<String> functionDeclarationParts;
 
     protected CreateFunctionalStatement(String kind) {
@@ -41,7 +77,9 @@ protected CreateFunctionalStatement(boolean orReplace, String kind,
     }
 
     /**
-     * @return the declaration parts after {@code CREATE FUNCTION|PROCEDURE}
+     * @return the declaration parts after {@code CREATE FUNCTION|PROCEDURE}. For a SQL Server
+     *         function with a structured {@link #getReturnType()}, these are the name and parameter
+     *         tokens before RETURNS; {@link #getRoutineBodyParts()} holds the remaining tokens.
      */
     public List<String> getFunctionDeclarationParts() {
         return functionDeclarationParts;
@@ -66,22 +104,43 @@ public void setOrReplace(boolean orReplace) {
      * @return a whitespace appended String with the declaration parts with some minimal formatting.
      */
     public String formatDeclaration() {
-        StringBuilder declaration = new StringBuilder();
-        int currIndex = 0;
-        while (currIndex < functionDeclarationParts.size()) {
-            String token = functionDeclarationParts.get(currIndex);
-            declaration.append(token);
-            // if the next token is a ; don't put a space
-            if (currIndex + 1 < functionDeclarationParts.size()) {
-                // peek ahead just to format nicely
-                String nextToken = functionDeclarationParts.get(currIndex + 1);
-                if (!nextToken.equals(";")) {
-                    declaration.append(" ");
-                }
+        StringBuilder builder = new StringBuilder();
+        return appendDeclarationTo(builder, builder::append).toString();
+    }
+
+    private StringBuilder appendDeclarationTo(StringBuilder builder,
+            Consumer<TableElement> printer) {
+        appendTokens(builder, functionDeclarationParts);
+        if (returnType != null) {
+            builder.append(' ');
+            returnType.appendTo(builder, printer);
+            if (routineBodyParts != null && !routineBodyParts.isEmpty()) {
+                builder.append(' ');
+                appendTokens(builder, routineBodyParts);
             }
-            currIndex++;
         }
-        return declaration.toString();
+        return builder;
+    }
+
+    private static void appendTokens(StringBuilder builder, List<String> tokens) {
+        if (tokens == null) {
+            return;
+        }
+        for (int i = 0; i < tokens.size(); i++) {
+            if (i > 0 && !";".equals(tokens.get(i))) {
+                builder.append(' ');
+            }
+            builder.append(tokens.get(i));
+        }
+    }
+
+    public StringBuilder appendTo(StringBuilder builder, Consumer<TableElement> printer) {
+        builder.append(operation.name().replace('_', ' ')).append(' ');
+        if (orReplace && operation == Operation.CREATE) {
+            builder.append("OR REPLACE ");
+        }
+        builder.append(kind).append(' ');
+        return appendDeclarationTo(builder, printer);
     }
 
     @Override
@@ -91,9 +150,8 @@ public <T, S> T accept(StatementVisitor<T> statementVisitor, S context) {
 
     @Override
     public String toString() {
-        return "CREATE "
-                + (orReplace ? "OR REPLACE " : "")
-                + kind + " " + formatDeclaration();
+        StringBuilder builder = new StringBuilder();
+        return appendTo(builder, builder::append).toString();
     }
 
     public CreateFunctionalStatement withFunctionDeclarationParts(

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

@@ -397,16 +397,9 @@ public <S> T visit(CreateView createView, S context) {
     public <S> T visit(Alter alter, S context) {
         alter.getTable().accept(fromItemVisitor, context);
         for (AlterExpression action : alter.getAlterExpressions()) {
-            if (action.getColDataTypeList() != null) {
-                action.getColDataTypeList().forEach(column -> TableDefinitionTraversal.visit(column,
-                        expression -> expression.accept(expressionVisitor, context),
-                        table -> table.accept(fromItemVisitor, context)));
-            }
-            if (action.getIndex() != null) {
-                TableDefinitionTraversal.visit(action.getIndex(),
-                        expression -> expression.accept(expressionVisitor, context),
-                        table -> table.accept(fromItemVisitor, context));
-            }
+            TableDefinitionTraversal.visit(action,
+                    expression -> expression.accept(expressionVisitor, context),
+                    table -> table.accept(fromItemVisitor, context));
         }
         return null;
     }
@@ -553,6 +546,13 @@ public <S> T visit(AlterSequence alterSequence, S context) {
 
     @Override
     public <S> T visit(CreateFunctionalStatement createFunctionalStatement, S context) {
+        if (createFunctionalStatement.getReturnType() != null
+                && createFunctionalStatement.getReturnType().getTableElements() != null) {
+            createFunctionalStatement.getReturnType().getTableElements()
+                    .forEach(element -> TableDefinitionTraversal.visit(element,
+                            expression -> expression.accept(expressionVisitor, context),
+                            table -> table.accept(fromItemVisitor, context)));
+        }
         return null;
     }
 

src/main/java/net/sf/jsqlparser/statement/alter/AlterExpressionPrimaryKey.java

@@ -0,0 +1,99 @@
+/*-
+ * #%L
+ * JSQLParser library
+ * %%
+ * Copyright (C) 2004 - 2026 JSQLParser
+ * %%
+ * Dual licensed under GNU LGPL 2.1 or Apache License 2.0
+ * #L%
+ */
+package net.sf.jsqlparser.statement.alter;
+
+import java.util.Iterator;
+import java.util.function.Consumer;
+import net.sf.jsqlparser.expression.Expression;
+import net.sf.jsqlparser.statement.create.table.Index;
+
+/**
+ * CockroachDB's ALTER PRIMARY KEY USING COLUMNS operation. Key elements and storage options are
+ * available through {@link #getIndex()}; hash sharding and the legacy WITH BUCKET_COUNT expression
+ * are represented separately.
+ */
+public class AlterExpressionPrimaryKey extends AlterExpression {
+    private boolean usingHash;
+    private Expression bucketCount;
+
+    public AlterExpressionPrimaryKey() {
+        setOperation(AlterOperation.ALTER_PRIMARY_KEY);
+        setIndex(new Index().withType("PRIMARY KEY"));
+    }
+
+    public boolean isUsingHash() {
+        return usingHash;
+    }
+
+    public void setUsingHash(boolean usingHash) {
+        this.usingHash = usingHash;
+    }
+
+    public Expression getBucketCount() {
+        return bucketCount;
+    }
+
+    public void setBucketCount(Expression bucketCount) {
+        this.bucketCount = bucketCount;
+    }
+
+    @Override
+    protected void appendBody(StringBuilder builder) {
+        appendDefinition(builder, expression -> builder.append(expression));
+    }
+
+    /** Shares statement rendering while preserving expression visitor customization. */
+    public StringBuilder appendTo(StringBuilder builder, Consumer<Expression> expressionPrinter) {
+        appendDefinition(builder, expressionPrinter);
+        appendCommonTail(builder);
+        return builder;
+    }
+
+    private void appendDefinition(StringBuilder builder, Consumer<Expression> expressionPrinter) {
+        builder.append("ALTER PRIMARY KEY USING COLUMNS (");
+        if (getIndex().getColumns() != null) {
+            for (Iterator<Index.ColumnParams> columns = getIndex().getColumns().iterator(); columns
+                    .hasNext();) {
+                columns.next().appendTo(builder, expressionPrinter);
+                if (columns.hasNext()) {
+                    builder.append(", ");
+                }
+            }
+        }
+        builder.append(')');
+        appendSharding(builder, expressionPrinter);
+        appendStorageOptions(builder, expressionPrinter);
+    }
+
+    private void appendSharding(StringBuilder builder, Consumer<Expression> expressionPrinter) {
+        if (usingHash) {
+            builder.append(" USING HASH");
+            if (bucketCount != null) {
+                builder.append(" WITH BUCKET_COUNT = ");
+                expressionPrinter.accept(bucketCount);
+            }
+        }
+    }
+
+    private void appendStorageOptions(StringBuilder builder,
+            Consumer<Expression> expressionPrinter) {
+        if (getIndex().getStorageParameters() != null) {
+            builder.append(" WITH (");
+            for (Iterator<Index.Option> options =
+                    getIndex().getStorageParameters().iterator(); options.hasNext();) {
+                options.next().appendTo(builder, expressionPrinter);
+                if (options.hasNext()) {
+                    builder.append(", ");
+                }
+            }
+            builder.append(')');
+        }
+    }
+}

src/main/java/net/sf/jsqlparser/statement/alter/AlterOperation.java

@@ -12,7 +12,7 @@
 import java.util.Locale;
 
 public enum AlterOperation {
-    ADD, ALTER, DROP, DROP_PRIMARY_KEY, DROP_UNIQUE, DROP_FOREIGN_KEY, MODIFY, CHANGE, CONVERT, COLLATE, ALGORITHM, RENAME, RENAME_TABLE, RENAME_INDEX, RENAME_KEY, RENAME_CONSTRAINT, COMMENT, COMMENT_WITH_EQUAL_SIGN, UNSPECIFIC, ADD_PARTITION, DROP_PARTITION, ATTACH_PARTITION, DETACH_PARTITION, DISCARD_PARTITION, IMPORT_PARTITION, TRUNCATE_PARTITION, COALESCE_PARTITION, REORGANIZE_PARTITION, EXCHANGE_PARTITION, ANALYZE_PARTITION, CHECK_PARTITION, OPTIMIZE_PARTITION, REBUILD_PARTITION, REPAIR_PARTITION, REMOVE_PARTITIONING, PARTITION_BY, SET_TABLE_OPTION, ENGINE, FORCE, KEY_BLOCK_SIZE, LOCK, DISCARD_TABLESPACE, IMPORT_TABLESPACE, DISABLE_KEYS, ENABLE_KEYS, ENABLE_ROW_LEVEL_SECURITY, DISABLE_ROW_LEVEL_SECURITY, FORCE_ROW_LEVEL_SECURITY, NO_FORCE_ROW_LEVEL_SECURITY;
+    ADD, ALTER, DROP, DROP_PRIMARY_KEY, DROP_UNIQUE, DROP_FOREIGN_KEY, MODIFY, CHANGE, CONVERT, COLLATE, ALGORITHM, RENAME, RENAME_TABLE, RENAME_INDEX, RENAME_KEY, RENAME_CONSTRAINT, COMMENT, COMMENT_WITH_EQUAL_SIGN, UNSPECIFIC, ADD_PARTITION, DROP_PARTITION, ATTACH_PARTITION, DETACH_PARTITION, DISCARD_PARTITION, IMPORT_PARTITION, TRUNCATE_PARTITION, COALESCE_PARTITION, REORGANIZE_PARTITION, EXCHANGE_PARTITION, ANALYZE_PARTITION, CHECK_PARTITION, OPTIMIZE_PARTITION, REBUILD_PARTITION, REPAIR_PARTITION, REMOVE_PARTITIONING, PARTITION_BY, SET_TABLE_OPTION, ENGINE, FORCE, KEY_BLOCK_SIZE, LOCK, DISCARD_TABLESPACE, IMPORT_TABLESPACE, DISABLE_KEYS, ENABLE_KEYS, ENABLE_ROW_LEVEL_SECURITY, DISABLE_ROW_LEVEL_SECURITY, FORCE_ROW_LEVEL_SECURITY, NO_FORCE_ROW_LEVEL_SECURITY, ALTER_PRIMARY_KEY;
 
     public static AlterOperation from(String operation) {
         return Enum.valueOf(AlterOperation.class, operation.toUpperCase(Locale.ROOT));

src/main/java/net/sf/jsqlparser/statement/create/function/FunctionReturnType.java

@@ -0,0 +1,98 @@
+/*-
+ * #%L
+ * JSQLParser library
+ * %%
+ * Copyright (C) 2004 - 2026 JSQLParser
+ * %%
+ * Dual licensed under GNU LGPL 2.1 or Apache License 2.0
+ * #L%
+ */
+package net.sf.jsqlparser.statement.create.function;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+import net.sf.jsqlparser.statement.create.table.ColDataType;
+import net.sf.jsqlparser.statement.create.table.TableElement;
+
+/** A SQL Server scalar, inline table or declared table return type. */
+public class FunctionReturnType implements Serializable {
+    private ColDataType dataType;
+    private boolean table;
+    private String tableVariable;
+    private List<TableElement> tableElements;
+
+    public ColDataType getDataType() {
+        return dataType;
+    }
+
+    public void setDataType(ColDataType dataType) {
+        this.dataType = dataType;
+    }
+
+    public boolean isTable() {
+        return table;
+    }
+
+    public void setTable(boolean table) {
+        this.table = table;
+    }
+
+    public String getTableVariable() {
+        return tableVariable;
+    }
+
+    public void setTableVariable(String variable) {
+        this.tableVariable = variable;
+    }
+
+    /** Null for an inline return table; otherwise columns and constraints in source order. */
+    public List<TableElement> getTableElements() {
+        return tableElements;
+    }
+
+    public void setTableElements(List<TableElement> elements) {
+        this.tableElements = elements;
+    }
+
+    public <T extends TableElement> List<T> getTableElements(Class<T> type) {
+        List<T> result = new ArrayList<>();
+        if (tableElements != null) {
+            for (TableElement element : tableElements) {
+                if (type.isInstance(element)) {
+                    result.add(type.cast(element));
+                }
+            }
+        }
+        return result;
+    }
+
+    public StringBuilder appendTo(StringBuilder builder, Consumer<TableElement> printer) {
+        builder.append("RETURNS ");
+        if (!table) {
+            return builder.append(dataType);
+        }
+        if (tableVariable != null) {
+            builder.append(tableVariable).append(' ');
+        }
+        builder.append("TABLE");
+        if (tableElements != null) {
+            builder.append(" (");
+            for (int i = 0; i < tableElements.size(); i++) {
+                if (i > 0) {
+                    builder.append(", ");
+                }
+                printer.accept(tableElements.get(i));
+            }
+            builder.append(')');
+        }
+        return builder;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder();
+        return appendTo(builder, builder::append).toString();
+    }
+}