From 19b54d045311dce25db10a9601c07f907a485c1c Mon Sep 17 00:00:00 2001 From: Minjae Lee <55116920+minleejae@users.noreply.github.com> Date: Sun, 15 Nov 2026 12:43:11 +0900 Subject: [PATCH 1/2] fix: parse MySQL mixed ADD COLUMN groups Preserve parenthesized ADD declarations in source order using existing table-element models and traversal. Retain mutable column accessors and visit/deparse every mixed column, constraint and index declaration. Cover mixed order, constraints first, metadata validation, expression visitors and compatibility with column-only groups. --- README.md | 1 + .../statement/alter/AlterExpression.java | 111 ++++++++- .../create/table/TableElementList.java | 4 +- .../util/TableDefinitionTraversal.java | 4 + .../util/deparser/AlterDeParser.java | 5 + .../validation/validator/AlterValidator.java | 15 +- .../net/sf/jsqlparser/parser/JSqlParserCC.jjt | 48 ++++ .../alter/MySqlAlterAddGroupAstTest.java | 225 ++++++++++++++++++ .../alter/MySqlAlterAddGroupTest.java | 33 +++ 9 files changed, 436 insertions(+), 10 deletions(-) create mode 100644 src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterAddGroupAstTest.java create mode 100644 src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterAddGroupTest.java diff --git a/README.md b/README.md index 6aab5f3ff4..bdfbe37f72 100644 --- a/README.md +++ b/README.md @@ -156,6 +156,7 @@ and missing syntax gets added on demand — [open an issue](https://github.com/J | **MySQL table maintenance** | `ANALYZE` · `CHECK` · `CHECKSUM` · `OPTIMIZE` · `REPAIR TABLE` | | **MySQL locks** | `LOCK TABLES` · `UNLOCK TABLES` · `LOCK INSTANCE FOR BACKUP` · `UNLOCK INSTANCE` | | **MySQL resource groups** | `CREATE`/`ALTER`/`DROP RESOURCE GROUP` · `SET RESOURCE GROUP` | +| **MySQL mixed ADD groups** | `ALTER TABLE … ADD [COLUMN] (columns, indexes, constraints)` | | **MySQL loadable functions** | `CREATE [AGGREGATE] FUNCTION … RETURNS … SONAME` | | **MySQL servers, plugins and components** | `CREATE SERVER` · `ALTER SERVER` with `OPTIONS (… PORT 3306)` · `INSTALL`/`UNINSTALL PLUGIN` · `INSTALL`/`UNINSTALL COMPONENT` | | **MySQL server administration** | `FLUSH` · `KILL` · `RESET PERSIST` · `HANDLER … OPEN`/`READ`/`CLOSE` | diff --git a/src/main/java/net/sf/jsqlparser/statement/alter/AlterExpression.java b/src/main/java/net/sf/jsqlparser/statement/alter/AlterExpression.java index 5513097abf..d5980de70e 100644 --- a/src/main/java/net/sf/jsqlparser/statement/alter/AlterExpression.java +++ b/src/main/java/net/sf/jsqlparser/statement/alter/AlterExpression.java @@ -30,6 +30,7 @@ import net.sf.jsqlparser.statement.create.table.NamedConstraint; import net.sf.jsqlparser.statement.create.table.KeyConstraint; import net.sf.jsqlparser.statement.create.table.TableElement; +import net.sf.jsqlparser.statement.create.table.TableElementList; import net.sf.jsqlparser.statement.create.table.IndexOptionSource; import net.sf.jsqlparser.statement.create.table.ConstraintKind; import net.sf.jsqlparser.statement.create.table.PartitionDefinition; @@ -50,6 +51,7 @@ public enum TableRenameKeyword { // private ColDataType dataType; private String columnOldName; private List colDataTypeList; + private List addGroupElements; private List columnDropNotNullList; private List columnSetNotNullList; private List columnDropDefaultList; @@ -434,15 +436,70 @@ private void setForeignKeyTablePart(String value, int partIndex) { table.setNameParts(parts); } + /** + * Returns the mutable column list, filtering out the other declarations of a mixed ADD group. + */ public List getColDataTypeList() { + if (hasAddGroupElements()) { + return new TableElementList<>(addGroupElements, ColumnDataType.class); + } return colDataTypeList; } + /** + * Returns the mutable declarations of a parenthesized mixed ADD group in source order. Parsed + * columns are {@link ColumnDataType} nodes shared with {@link #getColDataTypeList()}. + */ + public List getAddGroupElements() { + return addGroupElements; + } + + /** Copies the group membership, retaining the mutable column, index and constraint nodes. */ + public void setAddGroupElements(List elements) { + addGroupElements = elements == null ? null : new ArrayList<>(elements); + if (elements != null) { + colDataTypeList = null; + constraint = null; + index = null; + useBrackets = true; + } + } + + public boolean hasAddGroupElements() { + return operation == AlterOperation.ADD && addGroupElements != null; + } + + private E firstAddGroupElement(Class type) { + for (TableElement element : addGroupElements) { + if (type.isInstance(element)) { + return type.cast(element); + } + } + return null; + } + + private void replaceFirstAddGroupElement(Class type, E element) { + List elements = new TableElementList<>(addGroupElements, type); + if (elements.isEmpty()) { + if (element != null) { + elements.add(element); + } + } else if (element == null) { + elements.remove(0); + } else { + elements.set(0, element); + } + } + public void addColDataType(String columnName, ColDataType colDataType) { addColDataType(new ColumnDataType(columnName, false, colDataType, null)); } public void addColDataType(ColumnDataType columnDataType) { + if (hasAddGroupElements()) { + addGroupElements.add(columnDataType); + return; + } if (colDataTypeList == null) { colDataTypeList = new ArrayList<>(); } @@ -782,7 +839,11 @@ public void setUkName(String ukName) { } } + /** Returns the ordinary index, or the first ordinary index in a mixed ADD group. */ public Index getIndex() { + if (hasAddGroupElements()) { + return firstAddGroupElement(Index.class); + } return index; } @@ -878,8 +939,15 @@ public boolean hasActiveConstraintHeader() { return hasExplicitConstraintHeader(); } - /** Sets an index definition or target; a non-null value replaces any constraint definition. */ + /** + * Sets an index definition or target; a non-null value replaces any constraint definition. In a + * mixed ADD group, replaces or removes only its first ordinary index. + */ public void setIndex(Index index) { + if (hasAddGroupElements()) { + replaceFirstAddGroupElement(Index.class, index); + return; + } this.index = index; if (index != null) { clearReplacedConstraintAliases(null); @@ -887,13 +955,23 @@ public void setIndex(Index index) { } } - /** Returns the constraint definition, distinct from an ordinary index or a named target. */ + /** Returns the constraint definition, or the first constraint in a mixed ADD group. */ public NamedConstraint getConstraint() { + if (hasAddGroupElements()) { + return firstAddGroupElement(NamedConstraint.class); + } return constraint; } - /** Sets a constraint definition; a non-null value replaces any ordinary index definition. */ + /** + * Sets a constraint definition; a non-null value replaces any ordinary index definition. In a + * mixed ADD group, replaces or removes only its first constraint. + */ public void setConstraint(NamedConstraint constraint) { + if (hasAddGroupElements()) { + replaceFirstAddGroupElement(NamedConstraint.class, constraint); + return; + } clearReplacedConstraintAliases(constraint); this.constraint = constraint; if (constraint != null) { @@ -1208,7 +1286,9 @@ public final String toString() { @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.NPathComplexity", "PMD.ExcessiveMethodLength", "PMD.SwitchStmtsShouldHaveDefault"}) protected void appendBody(StringBuilder b) { - if (operation == AlterOperation.UNSPECIFIC) { + if (hasAddGroupElements()) { + appendAddGroupBody(b, b::append); + } else if (operation == AlterOperation.UNSPECIFIC) { b.append(optionalSpecifier); } else if (hasActiveConstraintHeader()) { toStringConstraintAlter(b); @@ -1250,7 +1330,28 @@ protected boolean usesColumnActionBody() { * deparsing. Subclasses with their own body dispatch override this method accordingly. */ public boolean hasActiveColumnDefinitions() { - return hasColumnDefinitionPayload() && usesGeneralBody(); + return hasAddGroupElements() || hasColumnDefinitionPayload() && usesGeneralBody(); + } + + /** Appends a mixed ADD group using the supplied renderer for every declaration. */ + public void appendAddGroupTo(StringBuilder b, Consumer elementPrinter) { + appendAddGroupBody(b, elementPrinter); + appendCommonTail(b); + } + + private void appendAddGroupBody(StringBuilder b, Consumer elementPrinter) { + b.append("ADD "); + if (hasColumn) { + b.append("COLUMN "); + } + b.append('('); + for (int i = 0; i < addGroupElements.size(); i++) { + if (i > 0) { + b.append(", "); + } + elementPrinter.accept(addGroupElements.get(i)); + } + b.append(')'); } /** Whether this action selects the general body, before choosing its active payload. */ diff --git a/src/main/java/net/sf/jsqlparser/statement/create/table/TableElementList.java b/src/main/java/net/sf/jsqlparser/statement/create/table/TableElementList.java index c221e986d0..cf35acad78 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/table/TableElementList.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/table/TableElementList.java @@ -20,12 +20,12 @@ import java.util.Objects; /** A mutable, filtered view preserving the other declarations in a table definition. */ -final class TableElementList extends AbstractList +public final class TableElementList extends AbstractList implements Serializable { private final List elements; private final Class type; - TableElementList(List elements, Class type) { + public TableElementList(List elements, Class type) { this.elements = elements; this.type = type; } diff --git a/src/main/java/net/sf/jsqlparser/util/TableDefinitionTraversal.java b/src/main/java/net/sf/jsqlparser/util/TableDefinitionTraversal.java index a6d1f05635..5ecac8def7 100644 --- a/src/main/java/net/sf/jsqlparser/util/TableDefinitionTraversal.java +++ b/src/main/java/net/sf/jsqlparser/util/TableDefinitionTraversal.java @@ -59,6 +59,10 @@ public static void visit(CreateIndex createIndex, Consumer expressio */ public static void visit(AlterExpression action, Consumer expressions, Consumer tables) { + if (action.hasAddGroupElements()) { + action.getAddGroupElements().forEach(element -> visit(element, expressions, tables)); + return; + } if (visitSpecialBody(action, expressions, tables)) { return; } diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/AlterDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/AlterDeParser.java index 5c09eb9bec..3164b31ecd 100644 --- a/src/main/java/net/sf/jsqlparser/util/deparser/AlterDeParser.java +++ b/src/main/java/net/sf/jsqlparser/util/deparser/AlterDeParser.java @@ -45,6 +45,11 @@ public void deParse(Alter alter) { } private void deParseAction(AlterExpression action) { + if (action.hasAddGroupElements()) { + TableElementDeParser elements = new TableElementDeParser(builder, expressionVisitor); + action.appendAddGroupTo(builder, elements::deParse); + return; + } if (action instanceof AlterForeignDataOptions) { ((AlterForeignDataOptions) action).appendTo(builder, expression -> expression.accept(expressionVisitor, null)); diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/AlterValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/AlterValidator.java index ece47d337a..d415b983c0 100644 --- a/src/main/java/net/sf/jsqlparser/util/validation/validator/AlterValidator.java +++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/AlterValidator.java @@ -85,8 +85,15 @@ public void validate(Alter alter, AlterExpression e) { validateOptionalColumnNames(c, e.getDropColumns()); } - validateConstraint(c, definition); - validateIndex(c, e, definition); + if (e.hasAddGroupElements()) { + for (TableElement element : e.getAddGroupElements()) { + validateConstraint(c, element); + validateIndex(c, e, element); + } + } else { + validateConstraint(c, definition); + validateIndex(c, e, definition); + } } } @@ -137,7 +144,9 @@ private boolean hasActiveDropColumns(AlterExpression expression) { private void validateIndex(ValidationCapability capability, AlterExpression expression, TableElement definition) { - Index index = expression.getIndex(); + Index index = expression.hasAddGroupElements() && definition instanceof Index + ? (Index) definition + : expression.getIndex(); boolean rename = expression.getOperation() == AlterOperation.RENAME_INDEX || expression.getOperation() == AlterOperation.RENAME_KEY; if (index == null || definition != index && !rename) { diff --git a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt index 80a3d42a77..97212fb77b 100644 --- a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt +++ b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt @@ -25361,6 +25361,47 @@ Truncate Truncate(): } } + +/** MySQL ADD (table_element_list), preserving interleaved columns, indexes and constraints. */ +void MySqlAlterAddGroup(AlterExpression alterExp): +{ + List elements = new ArrayList(); + TableElement element; + boolean mixed = false; +} +{ + [ { alterExp.hasColumn(true); } ] + "(" element=MySqlAlterAddGroupElement() { elements.add(element); } + ( "," element=MySqlAlterAddGroupElement() { elements.add(element); } )* + ")" + { + for (TableElement item : elements) { + if (!(item instanceof AlterExpression.ColumnDataType)) { + mixed = true; + } + } + if (mixed) { + alterExp.setAddGroupElements(elements); + } else { + // Keep the existing representation and accessors for column-only groups. + alterExp.useBrackets(true); + for (TableElement item : elements) { + alterExp.addColDataType((AlterExpression.ColumnDataType) item); + } + } + } +} + +TableElement MySqlAlterAddGroupElement(): +{ + TableElement element; +} +{ + ( LOOKAHEAD(3) element=CreateTableConstraint() + | element=AlterExpressionColumnDataType() ) + { return element; } +} + /** * Parses common column-level changes shared between the COLUMN-prefixed and bare forms: * DROP DEFAULT, SET DEFAULT, SET NOT NULL, SET VISIBLE/INVISIBLE, and bracketed multi-column @@ -26547,6 +26588,13 @@ AlterExpression AlterExpressionAddAlterModify(): { alterExp.getOperation() == AlterOperation.ADD }) alterExp=AddPartition() | + LOOKAHEAD({ alterExp.getOperation() == AlterOperation.ADD + && (getAsString(Feature.dialect) == null + || Dialect.MYSQL.name().equals(getAsString(Feature.dialect))) + && (getToken(1).kind == OPENING_BRACKET + || getToken(1).kind == K_COLUMN && getToken(2).kind == OPENING_BRACKET) }) + MySqlAlterAddGroup(alterExp) + | LOOKAHEAD(3) ( ( LOOKAHEAD(2) ( diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterAddGroupAstTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterAddGroupAstTest.java new file mode 100644 index 0000000000..7be690ecf9 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterAddGroupAstTest.java @@ -0,0 +1,225 @@ +/*- + * #%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 static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.ArrayList; +import java.util.List; +import java.util.Set; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.expression.ExpressionVisitorAdapter; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.statement.alter.AlterExpression.ColumnDataType; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.StmtFeature; +import net.sf.jsqlparser.statement.create.table.CheckConstraint; +import net.sf.jsqlparser.statement.create.table.ColDataType; +import net.sf.jsqlparser.statement.create.table.ForeignKeyConstraint; +import net.sf.jsqlparser.statement.create.table.Index; +import net.sf.jsqlparser.statement.create.table.KeyConstraint; +import net.sf.jsqlparser.statement.create.table.TableElement; +import net.sf.jsqlparser.statement.select.SelectVisitorAdapter; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.ExpressionDeParser; +import net.sf.jsqlparser.util.deparser.SelectDeParser; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.Validation; +import net.sf.jsqlparser.util.validation.feature.MySqlVersion; +import net.sf.jsqlparser.util.validation.metadata.DatabaseMetaDataValidation; +import net.sf.jsqlparser.util.validation.metadata.Named; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +/** + * MySQL's ADD (table_element_list), see https://dev.mysql.com/doc/refman/8.4/en/alter-table.html. + */ +class MySqlAlterAddGroupAstTest { + @ParameterizedTest + @ValueSource(strings = { + "a INT, CONSTRAINT ck1 CHECK (a > 0), b INT, CONSTRAINT ck2 CHECK (b > 0) NOT ENFORCED", + "a INT, KEY ix (a), b INT DEFAULT 7, CONSTRAINT uq UNIQUE (b)", + "CONSTRAINT ck CHECK (a > 0), a INT", + "a INT, CONSTRAINT fk FOREIGN KEY (a) REFERENCES parent(id), b INT", + "CONSTRAINT ck CHECK (id > 0), KEY ix (id)"}) + void retainsInterleavedDeclarationsAndFollowingActions(String elements) throws Exception { + for (boolean mysql : new boolean[] {false, true}) { + for (String keyword : new String[] {"ADD", "ADD COLUMN"}) { + String sql = + "ALTER TABLE t " + keyword + " (" + elements + "), ADD COLUMN extra INT"; + Alter alter = (Alter) assertSqlCanBeParsedAndDeparsed(sql, true, parser -> { + if (mysql) { + parser.withDialect(Dialect.MYSQL); + } + }); + assertEquals(2, alter.getAlterExpressions().size()); + assertTrue(alter.getAlterExpressions().get(0).hasAddGroupElements()); + assertFalse(alter.getAlterExpressions().get(1).hasAddGroupElements()); + assertEquals(sql, alter.toString()); + assertThat(new Validation(List.of(MySqlVersion.V8_0), sql).validate()).isEmpty(); + } + } + } + + @Test + void exposesOrderedNodesAndMutableLegacyViews() throws Exception { + Alter alter = parse("ALTER TABLE t ADD COLUMN (a INT, CONSTRAINT ck CHECK (a > 0) " + + "NOT ENFORCED, b INT, KEY ix (a), CONSTRAINT uq UNIQUE (b))"); + AlterExpression group = alter.getAlterExpressions().get(0); + List elements = group.getAddGroupElements(); + assertThat(elements).extracting(Object::getClass).containsExactly(ColumnDataType.class, + CheckConstraint.class, ColumnDataType.class, Index.class, KeyConstraint.class); + assertSame(elements.get(0), group.getColDataTypeList().get(0)); + assertSame(elements.get(2), group.getColDataTypeList().get(1)); + assertSame(elements.get(1), group.getConstraint()); + assertEquals(Boolean.FALSE, ((CheckConstraint) group.getConstraint()).getEnforced()); + assertSame(elements.get(3), group.getIndex()); + + group.getColDataTypeList().set(1, column("c")); + group.getColDataTypeList().add(1, column("d")); + group.getColDataTypeList().remove(0); + group.addColDataType(column("e")); + group.getConstraint().setName("edited_ck"); + group.getIndex().setName("edited_ix"); + assertEquals("ALTER TABLE t ADD COLUMN (CONSTRAINT edited_ck CHECK (a > 0) NOT ENFORCED, " + + "d INT, c INT, KEY edited_ix (a), CONSTRAINT uq UNIQUE (b), e INT)", + alter.toString()); + + CheckConstraint replacement = (CheckConstraint) parse("ALTER TABLE t ADD CHECK (id > 1)") + .getAlterExpressions().get(0).getConstraint(); + group.setConstraint(replacement); + group.setIndex(null); + assertSame(replacement, elements.get(0)); + assertNull(group.getIndex()); + assertThat(elements).filteredOn(KeyConstraint.class::isInstance).hasSize(1); + } + + @Test + void copiesMembershipButKeepsEditableNodes() throws Exception { + AlterExpression parsed = parse("ALTER TABLE t ADD (a INT, CHECK (a > 0))") + .getAlterExpressions().get(0); + List input = new ArrayList<>(parsed.getAddGroupElements()); + AlterExpression group = new AlterExpression(); + group.setOperation(AlterOperation.ADD); + group.setAddGroupElements(input); + input.clear(); + assertEquals(2, group.getAddGroupElements().size()); + assertSame(parsed.getColDataTypeList().get(0), group.getColDataTypeList().get(0)); + group.getColDataTypeList().get(0).setColumnName("edited"); + assertEquals("edited", parsed.getColDataTypeList().get(0).getColumnName()); + group.setAddGroupElements(null); + assertFalse(group.hasAddGroupElements()); + } + + @Test + void deparsesEveryStructuredExpressionInOrder() throws Exception { + Alter alter = parse("ALTER TABLE t ADD (a INT DEFAULT 7, " + + "CONSTRAINT ck CHECK (a > 0), b INT DEFAULT 9)"); + List visited = new ArrayList<>(); + ExpressionDeParser expressions = new ExpressionDeParser() { + @Override + public StringBuilder visit(LongValue value, S context) { + visited.add(value.getValue()); + return getBuilder().append(value.getValue() + 100); + } + }; + StringBuilder output = new StringBuilder(); + alter.accept(new StatementDeParser(expressions, new SelectDeParser(), output), null); + assertEquals(List.of(7L, 0L, 9L), visited); + String expected = "ALTER TABLE t ADD (a INT DEFAULT 107, " + + "CONSTRAINT ck CHECK (a > 100), b INT DEFAULT 109)"; + assertEquals(expected, output.toString()); + assertEquals(expected, parse(output.toString()).toString()); + } + + @Test + void statementVisitorSeesEveryDeclarationWithItsContext() throws Exception { + Alter alter = parse("ALTER TABLE t ADD (a INT DEFAULT 7, " + + "CONSTRAINT ck CHECK (a > 0), b INT DEFAULT 9)"); + List visited = new ArrayList<>(); + ExpressionVisitorAdapter expressions = new ExpressionVisitorAdapter() { + @Override + public Void visit(LongValue value, S context) { + assertEquals("group", context); + visited.add(value.getValue()); + return null; + } + }; + alter.accept(new StatementVisitorAdapter<>(new SelectVisitorAdapter<>(expressions)), + "group"); + assertEquals(List.of(7L, 0L, 9L), visited); + assertThat(alter.getFeatures().getCertain()).contains(StmtFeature.MODIFIES_SCHEMA); + } + + @Test + void visitsForeignKeysAndAllConstraintAndIndexNames() throws Exception { + Alter alter = parse("ALTER TABLE child ADD (parent_id INT, CONSTRAINT fk " + + "FOREIGN KEY (parent_id) REFERENCES parent (id), other_id INT)"); + assertInstanceOf(ForeignKeyConstraint.class, + alter.getAlterExpressions().get(0).getConstraint()); + assertThat(new TablesNamesFinder<>().getTables(alter)) + .containsExactlyInAnyOrder("child", "parent"); + + List names = new ArrayList<>(); + Set introduced = Set.of("ck1", "ck2", "ix1", "ix2"); + DatabaseMetaDataValidation metadata = name -> { + names.add(name); + return !introduced.contains(name.getFqn()); + }; + String sql = "ALTER TABLE t ADD (CONSTRAINT ck1 CHECK (id > 0), KEY ix1 (id), " + + "CONSTRAINT ck2 CHECK (id < 10), KEY ix2 (id))"; + assertThat(new Validation(List.of(metadata), sql).validate()).isEmpty(); + assertThat(names).extracting(Named::getFqn).containsAll(introduced); + } + + @ParameterizedTest + @ValueSource(strings = {"ADD (a INT, b INT)", "ADD COLUMN (a INT)", + "MODIFY (a INT, b INT)"}) + void keepsColumnOnlyAndModifyRepresentations(String action) throws Exception { + AlterExpression expression = parse("ALTER TABLE t " + action).getAlterExpressions().get(0); + assertNull(expression.getAddGroupElements()); + assertFalse(expression.getColDataTypeList().isEmpty()); + expression.getColDataTypeList().get(0).setColumnName("edited"); + assertTrue(expression.toString().contains("edited")); + } + + @ParameterizedTest + @ValueSource(strings = {"ADD ()", "ADD (a INT,)", "ADD (LIKE parent)", + "ADD (a INT, CONSTRAINT ck CHECK ())"}) + void rejectsMalformedGroups(String action) { + for (boolean mysql : new boolean[] {false, true}) { + assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil + .parse("ALTER TABLE t " + action, parser -> { + if (mysql) { + parser.withDialect(Dialect.MYSQL); + } + })); + } + } + + private static ColumnDataType column(String name) { + return new ColumnDataType(name, false, new ColDataType("INT"), null); + } + + private static Alter parse(String sql) throws JSQLParserException { + return (Alter) CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.MYSQL)); + } +} diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterAddGroupTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterAddGroupTest.java new file mode 100644 index 0000000000..0d5bc2200b --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterAddGroupTest.java @@ -0,0 +1,33 @@ +/*- + * #%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 static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class MySqlAlterAddGroupTest { + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void parsesColumnsAndConstraintInOneGroup(boolean mysql) throws Exception { + String sql = "ALTER TABLE edge_t ADD COLUMN (a INT, b INT, " + + "CONSTRAINT edge_ck CHECK (a < b) NOT ENFORCED)"; + Alter alter = (Alter) assertSqlCanBeParsedAndDeparsed(sql, true, parser -> { + if (mysql) { + parser.withDialect(Dialect.MYSQL); + } + }); + assertEquals(1, alter.getAlterExpressions().size()); + assertEquals(2, alter.getAlterExpressions().get(0).getColDataTypeList().size()); + } +} From b499a144d7e043c6ae61a4c25a4975bfd288f035 Mon Sep 17 00:00:00 2001 From: Minjae Lee <55116920+minleejae@users.noreply.github.com> Date: Sun, 15 Nov 2026 13:01:22 +0900 Subject: [PATCH 2/2] fix: make mixed ADD element updates explicit Update the backing group list directly when replacing or removing its first constraint or index. This preserves filtered-view semantics while letting SpotBugs observe the mutation without a suppression. Cover append when an element kind is absent and preservation of the remaining declarations when the first constraint is removed. --- .../statement/alter/AlterExpression.java | 19 +++++++++++-------- .../alter/MySqlAlterAddGroupAstTest.java | 8 ++++++++ 2 files changed, 19 insertions(+), 8 deletions(-) diff --git a/src/main/java/net/sf/jsqlparser/statement/alter/AlterExpression.java b/src/main/java/net/sf/jsqlparser/statement/alter/AlterExpression.java index d5980de70e..9029633649 100644 --- a/src/main/java/net/sf/jsqlparser/statement/alter/AlterExpression.java +++ b/src/main/java/net/sf/jsqlparser/statement/alter/AlterExpression.java @@ -479,15 +479,18 @@ private E firstAddGroupElement(Class type) { } private void replaceFirstAddGroupElement(Class type, E element) { - List elements = new TableElementList<>(addGroupElements, type); - if (elements.isEmpty()) { - if (element != null) { - elements.add(element); + for (int i = 0; i < addGroupElements.size(); i++) { + if (type.isInstance(addGroupElements.get(i))) { + if (element == null) { + addGroupElements.remove(i); + } else { + addGroupElements.set(i, element); + } + return; } - } else if (element == null) { - elements.remove(0); - } else { - elements.set(0, element); + } + if (element != null) { + addGroupElements.add(element); } } diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterAddGroupAstTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterAddGroupAstTest.java index 7be690ecf9..f6171a26c2 100644 --- a/src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterAddGroupAstTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/alter/MySqlAlterAddGroupAstTest.java @@ -110,6 +110,14 @@ void exposesOrderedNodesAndMutableLegacyViews() throws Exception { assertSame(replacement, elements.get(0)); assertNull(group.getIndex()); assertThat(elements).filteredOn(KeyConstraint.class::isInstance).hasSize(1); + + Index appended = new Index().withType("KEY").withName("appended") + .withColumnsNames(List.of("c")); + group.setIndex(appended); + assertSame(appended, elements.get(elements.size() - 1)); + group.setConstraint(null); + assertInstanceOf(KeyConstraint.class, group.getConstraint()); + assertSame(appended, group.getIndex()); } @Test