From 95ad9088a56f36979a064c7fc0992ada054bf7e0 Mon Sep 17 00:00:00 2001 From: Jake Wang Date: Thu, 24 Sep 2026 05:48:26 -0400 Subject: [PATCH 001/234] fix: default wildcard exclusions to EXCEPT (#2652) Signed-off-by: Jake Wang --- .../statement/select/AllColumnsTest.java | 62 +++++++++++++++++++ 1 file changed, 62 insertions(+) diff --git a/src/test/java/net/sf/jsqlparser/statement/select/AllColumnsTest.java b/src/test/java/net/sf/jsqlparser/statement/select/AllColumnsTest.java index 7f5aaba4c5..c95b5cdc44 100644 --- a/src/test/java/net/sf/jsqlparser/statement/select/AllColumnsTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/select/AllColumnsTest.java @@ -9,7 +9,17 @@ */ package net.sf.jsqlparser.statement.select; +import static net.sf.jsqlparser.test.TestUtils.assertDeparse; +import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +import static org.junit.jupiter.api.Assertions.assertEquals; + import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.ColumnsTransformer; +import net.sf.jsqlparser.expression.ColumnsTransformer.ColumnsTransformerType; +import net.sf.jsqlparser.expression.operators.relational.ParenthesedExpressionList; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.schema.Table; import net.sf.jsqlparser.test.TestUtils; import org.junit.jupiter.api.Test; @@ -31,4 +41,56 @@ void testDuckDBQuerySyntax() throws JSQLParserException { + "FROM orders"; TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true); } + + @Test + void addExceptColumnToNewWildcard() throws JSQLParserException { + AllColumns columns = new AllColumns(); + columns.addTransformer(new ColumnsTransformer(ColumnsTransformerType.EXCEPT) + .setExceptColumns(new ParenthesedExpressionList<>(new Column("hidden")))); + PlainSelect select = new PlainSelect().addSelectItem(columns).withFromItem(new Table("t")); + + String expected = "SELECT * EXCEPT (hidden) FROM t"; + assertEquals(expected, select.toString()); + assertDeparse(select, expected); + assertSqlCanBeParsedAndDeparsed(expected); + } + + @Test + void setExceptColumnsOnParsedWildcard() throws JSQLParserException { + PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse("SELECT * FROM t"); + AllColumns columns = select.getSelectItem(0).getExpression(AllColumns.class); + columns.addTransformer(new ColumnsTransformer(ColumnsTransformerType.EXCEPT) + .setExceptColumns(new ParenthesedExpressionList<>(new Column("hidden")))); + + String expected = "SELECT * EXCEPT (hidden) FROM t"; + assertEquals(expected, select.toString()); + assertDeparse(select, expected); + assertSqlCanBeParsedAndDeparsed(expected); + } + + @Test + void addExceptColumnToParsedTableWildcard() throws JSQLParserException { + PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse("SELECT t.* FROM t"); + AllTableColumns columns = select.getSelectItem(0).getExpression(AllTableColumns.class); + columns.addTransformer(new ColumnsTransformer(ColumnsTransformerType.EXCEPT) + .setExceptColumns(new ParenthesedExpressionList<>(new Column("hidden")))); + + String expected = "SELECT t.* EXCEPT (hidden) FROM t"; + assertEquals(expected, select.toString()); + assertDeparse(select, expected); + assertSqlCanBeParsedAndDeparsed(expected); + } + + @Test + void preserveExplicitExcludeTransformer() throws JSQLParserException { + AllColumns columns = new AllColumns(); + columns.addTransformer(new ColumnsTransformer(ColumnsTransformerType.EXCLUDE) + .setExceptColumns(new ParenthesedExpressionList<>(new Column("hidden")))); + PlainSelect select = new PlainSelect().addSelectItem(columns).withFromItem(new Table("t")); + + String expected = "SELECT * EXCLUDE (hidden) FROM t"; + assertEquals(expected, select.toString()); + assertDeparse(select, expected); + assertSqlCanBeParsedAndDeparsed(expected); + } } From 8eab5a525fccbe9b735bede925c715f1bdb82764 Mon Sep 17 00:00:00 2001 From: Minjae Lee Date: Thu, 24 Sep 2026 18:49:26 +0900 Subject: [PATCH 002/234] fix: support comment column names in ALTER TABLE (#2674) Signed-off-by: minleejae --- .../net/sf/jsqlparser/parser/JSqlParserCC.jjt | 4 +- src/site/sphinx/usage.rst | 19 ++++ .../alter/AlterCommentColumnTest.java | 91 +++++++++++++++++++ 3 files changed, 113 insertions(+), 1 deletion(-) create mode 100644 src/test/java/net/sf/jsqlparser/statement/alter/AlterCommentColumnTest.java diff --git a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt index 1411612de7..b81ad5bbba 100644 --- a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt +++ b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt @@ -3066,6 +3066,7 @@ Token KeywordOrIdentifier(): | tk = | tk = | tk = + | tk = ) { return tk; } } @@ -17262,7 +17263,8 @@ AlterExpression AlterExpressionAddAlterModify(): constraints=AlterExpressionConstraintState() { alterExp.setConstraints(constraints); } [ AlterExpressionUsingIndex(alterExp) ] | - LOOKAHEAD(2) ( + // Include the literal: COLUMN comment is a column definition, not a COMMENT clause. + LOOKAHEAD(RelObjectName() ) ( sk3=RelObjectName() tk= { alterExp.withColumnName(sk3).withCommentText(tk.image); } ) | diff --git a/src/site/sphinx/usage.rst b/src/site/sphinx/usage.rst index 6e4c96feb2..9c1caf7127 100644 --- a/src/site/sphinx/usage.rst +++ b/src/site/sphinx/usage.rst @@ -811,6 +811,25 @@ One grammar covers every supported RDBMS, but a few pieces of syntax mean differ Features set explicitly *after* the preset win over it. +ALTER column names +~~~~~~~~~~~~~~~~~~ + +Non-reserved names such as ``comment`` work unquoted in ``ADD``, ``MODIFY``, +``CHANGE``, ``DROP`` and ``RENAME`` column actions. The ``COLUMN`` keyword does +not change how the name is interpreted. Column definitions remain editable: + +.. code-block:: java + + Alter alter = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE t MODIFY COLUMN comment TEXT", + parser -> parser.withDialect(Dialect.MYSQL)); + AlterExpression.ColumnDataType column = alter.getAlterExpressions().get(0) + .getColDataTypeList().get(0); + column.setColumnName("notes"); + column.getColDataType().setDataType("LONGTEXT"); + // ALTER TABLE t MODIFY COLUMN notes LONGTEXT + String sql = alter.toString(); + PostgreSQL names and literals ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/AlterCommentColumnTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/AlterCommentColumnTest.java new file mode 100644 index 0000000000..fc74b4e30a --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/AlterCommentColumnTest.java @@ -0,0 +1,91 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class AlterCommentColumnTest { + @ParameterizedTest + @ValueSource(strings = { + "ADD COLUMN comment TEXT", "ADD comment TEXT", "MODIFY COLUMN comment TEXT", + "MODIFY comment TEXT", "MODIFY COLUMN `comment` TEXT", + "MODIFY COLUMN comment TEXT COMMENT 'note' AFTER id", + "CHANGE COLUMN comment comment2 TEXT", "CHANGE COLUMN old_name comment TEXT", + "DROP COLUMN comment", "DROP comment", "RENAME COLUMN comment TO comment2", + "RENAME COLUMN old_name TO comment" + }) + void roundTripsUnquotedCommentColumn(String action) throws JSQLParserException { + for (Dialect dialect : new Dialect[] {null, Dialect.MYSQL}) { + Alter alter = parse("ALTER TABLE t " + action, dialect); + assertEquals(1, alter.getAlterExpressions().size()); + assertRoundTrip(alter, dialect); + } + } + + @Test + void exposesEditableColumnDefinitionInsteadOfColumnComment() throws JSQLParserException { + Alter alter = parse("ALTER TABLE t MODIFY COLUMN comment TEXT", Dialect.MYSQL); + AlterExpression action = alter.getAlterExpressions().get(0); + assertEquals(AlterOperation.MODIFY, action.getOperation()); + assertNull(action.getCommentText()); + AlterExpression.ColumnDataType column = action.getColDataTypeList().get(0); + assertEquals("comment", column.getColumnName()); + assertEquals("TEXT", column.getColDataType().getDataType()); + column.setColumnName("notes"); + column.getColDataType().setDataType("LONGTEXT"); + assertEquals("ALTER TABLE t MODIFY COLUMN notes LONGTEXT", alter.toString()); + assertRoundTrip(alter, Dialect.MYSQL); + } + + @Test + void exposesBothNamesInRenameAndChange() throws JSQLParserException { + Alter rename = parse("ALTER TABLE t RENAME COLUMN comment TO notes", Dialect.MYSQL); + AlterExpression action = rename.getAlterExpressions().get(0); + assertEquals("comment", action.getColumnOldName()); + assertEquals("notes", action.getColumnName()); + action.setColumnName("remarks"); + assertEquals("ALTER TABLE t RENAME COLUMN comment TO remarks", rename.toString()); + assertRoundTrip(rename, Dialect.MYSQL); + Alter change = parse("ALTER TABLE t CHANGE COLUMN comment notes TEXT", Dialect.MYSQL); + assertEquals("comment", change.getAlterExpressions().get(0).getColumnOldName()); + assertEquals("notes", + change.getAlterExpressions().get(0).getColDataTypeList().get(0).getColumnName()); + } + + @ParameterizedTest + @ValueSource(strings = {"ALTER c COMMENT 'description'", "COMMENT = 'table description'", + "DROP COLUMN type", "DROP INDEX idx", "DROP CONSTRAINT ck", "RENAME TO other", + "RENAME INDEX idx TO other_idx", "RENAME CONSTRAINT ck TO other_ck"}) + void preservesOtherAlterBranches(String action) throws JSQLParserException { + assertRoundTrip(parse("ALTER TABLE t " + action, null), null); + } + + private static Alter parse(String sql, Dialect dialect) throws JSQLParserException { + return (Alter) CCJSqlParserUtil.parse(sql, p -> { + if (dialect != null) { + p.withDialect(dialect); + } + }); + } + + private static void assertRoundTrip(Alter alter, Dialect dialect) throws JSQLParserException { + StringBuilder buffer = new StringBuilder(); + alter.accept(new StatementDeParser(buffer), null); + assertEquals(alter.toString(), buffer.toString()); + assertEquals(alter.toString(), parse(buffer.toString(), dialect).toString()); + } +} From dd72b4f578ea672531e162d4c61799a6617ae035 Mon Sep 17 00:00:00 2001 From: Minjae Lee Date: Thu, 24 Sep 2026 18:50:28 +0900 Subject: [PATCH 003/234] feat: support MySQL named foreign key and check drops (#2675) Signed-off-by: minleejae --- .../statement/alter/AlterExpression.java | 17 +++- .../statement/alter/AlterExpressionDrop.java | 15 +-- .../statement/alter/AlterOperation.java | 2 +- .../net/sf/jsqlparser/parser/JSqlParserCC.jjt | 15 +++ src/site/sphinx/usage.rst | 23 +++++ .../alter/MySqlDropConstraintTest.java | 91 +++++++++++++++++++ 6 files changed, 149 insertions(+), 14 deletions(-) create mode 100644 src/test/java/net/sf/jsqlparser/statement/alter/MySqlDropConstraintTest.java 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 58c277a884..0f62330c20 100644 --- a/src/main/java/net/sf/jsqlparser/statement/alter/AlterExpression.java +++ b/src/main/java/net/sf/jsqlparser/statement/alter/AlterExpression.java @@ -504,6 +504,11 @@ public void setColumnOldName(String columnOldName) { this.columnOldName = columnOldName; } + /** + * Returns the constraint name, including any SQL identifier quotes. For named + * {@link AlterOperation#DROP_FOREIGN_KEY} and {@link AlterOperation#DROP_CHECK} actions, this + * is the deletion target; {@link #getPkColumns()} is not used. + */ public String getConstraintName() { return this.constraintName; } @@ -884,6 +889,7 @@ protected boolean isDropSpecialOperation() { case DROP_PRIMARY_KEY: case DROP_UNIQUE: case DROP_FOREIGN_KEY: + case DROP_CHECK: return true; case DROP: return columnName == null && pkColumns != null && !pkColumns.isEmpty(); @@ -1041,8 +1047,15 @@ protected void toStringDropSpecial(StringBuilder b) { b.append("DROP UNIQUE (").append(PlainSelect.getStringList(pkColumns)).append(')'); break; case DROP_FOREIGN_KEY: - b.append("DROP FOREIGN KEY (").append(PlainSelect.getStringList(pkColumns)) - .append(')'); + b.append("DROP FOREIGN KEY "); + if (constraintName != null) { + b.append(constraintName); + } else { + b.append('(').append(PlainSelect.getStringList(pkColumns)).append(')'); + } + break; + case DROP_CHECK: + b.append("DROP CHECK ").append(constraintName); break; default: // Oracle Multi Column Drop diff --git a/src/main/java/net/sf/jsqlparser/statement/alter/AlterExpressionDrop.java b/src/main/java/net/sf/jsqlparser/statement/alter/AlterExpressionDrop.java index 37e3b85872..d8a56fbd71 100644 --- a/src/main/java/net/sf/jsqlparser/statement/alter/AlterExpressionDrop.java +++ b/src/main/java/net/sf/jsqlparser/statement/alter/AlterExpressionDrop.java @@ -19,18 +19,11 @@ public class AlterExpressionDrop extends AlterExpression { @Override protected void appendBody(StringBuilder b) { + if (isDropSpecialOperation()) { + toStringDropSpecial(b); + return; + } switch (getOperation()) { - case DROP_PRIMARY_KEY: - b.append("DROP PRIMARY KEY "); - break; - case DROP_UNIQUE: - b.append("DROP UNIQUE (") - .append(PlainSelect.getStringList(getPkColumns())).append(')'); - break; - case DROP_FOREIGN_KEY: - b.append("DROP FOREIGN KEY (") - .append(PlainSelect.getStringList(getPkColumns())).append(')'); - break; case DROP_PARTITION: b.append("DROP PARTITION ") .append(PlainSelect.getStringList(getPartitions())); diff --git a/src/main/java/net/sf/jsqlparser/statement/alter/AlterOperation.java b/src/main/java/net/sf/jsqlparser/statement/alter/AlterOperation.java index 52bdc23ce7..bca23bbe4c 100644 --- a/src/main/java/net/sf/jsqlparser/statement/alter/AlterOperation.java +++ b/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, ALTER_PRIMARY_KEY; + ADD, ALTER, DROP, DROP_PRIMARY_KEY, DROP_UNIQUE, DROP_FOREIGN_KEY, DROP_CHECK, 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)); diff --git a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt index b81ad5bbba..8952a22fe4 100644 --- a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt +++ b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt @@ -17054,6 +17054,12 @@ AlterExpression AlterExpressionDrop(): { { alterExp.setOperation(AlterOperation.DROP); } ( + LOOKAHEAD({ Dialect.MYSQL.name().equals(getAsString(Feature.dialect)) + && (getToken(1).kind == K_CHECK + || getToken(1).kind == K_FOREIGN && getToken(2).kind == K_KEY + && getToken(3).kind != OPENING_BRACKET) }) + MySqlDropNamedConstraint(alterExp) + | ( { alterExp = new AlterExpressionPartition(); @@ -17119,6 +17125,15 @@ AlterExpression AlterExpressionDrop(): { return alterExp; } } +/** A MySQL deletion target is a constraint name, not a list of key columns. */ +void MySqlDropNamedConstraint(AlterExpression alterExp): +{ String name; } +{ + ( { alterExp.setOperation(AlterOperation.DROP_FOREIGN_KEY); } + | { alterExp.setOperation(AlterOperation.DROP_CHECK); } ) + name=RelObjectName() { alterExp.setConstraintName(name); } +} + /** * Parses partition maintenance operations within AlterExpression. * Handles: TRUNCATE/ANALYZE/CHECK/OPTIMIZE/REBUILD/REPAIR PARTITION, diff --git a/src/site/sphinx/usage.rst b/src/site/sphinx/usage.rst index 9c1caf7127..ef25ee681f 100644 --- a/src/site/sphinx/usage.rst +++ b/src/site/sphinx/usage.rst @@ -252,6 +252,29 @@ explicit index owners, without reporting catalog-only object names as tables. The statement deparser delegates real tables to its configured select deparser. MySQL ALGORITHM/LOCK tokens retain their order and optional equals signs. +MySQL named constraint drops +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +With ``Dialect.MYSQL``, ``DROP FOREIGN KEY name`` and ``DROP CHECK name`` +expose the target through ``AlterExpression.getConstraintName()``. Inspect +``getOperation()`` for ``DROP_FOREIGN_KEY`` or ``DROP_CHECK``. Identifier +quotes are preserved, and changing the name changes both SQL renderers. +These named targets do not populate the legacy ``getPkColumns()`` list. + +.. code-block:: java + + Alter alter = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE child DROP FOREIGN KEY fk_parent", + parser -> parser.withDialect(Dialect.MYSQL)); + AlterExpression drop = alter.getAlterExpressions().get(0); + drop.setConstraintName("fk_customer"); + // ALTER TABLE child DROP FOREIGN KEY fk_customer + String sql = alter.toString(); + + // The same API also supports constructing an action without parsing SQL. + AlterExpression checkDrop = new AlterExpression() + .withOperation(AlterOperation.DROP_CHECK).withConstraintName("positive_id"); + Inspect PostgreSQL schema statements ------------------------------------ diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/MySqlDropConstraintTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/MySqlDropConstraintTest.java new file mode 100644 index 0000000000..8e9d5f7a73 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/MySqlDropConstraintTest.java @@ -0,0 +1,91 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class MySqlDropConstraintTest { + @ParameterizedTest + @ValueSource(strings = {"DROP FOREIGN KEY fk1", "DROP FOREIGN KEY `fk name`", + "DROP CHECK c1", "DROP CHECK `check name`", + "DROP FOREIGN KEY fk1, DROP CHECK c1", + "DROP FOREIGN KEY fk1, ALGORITHM = INPLACE, LOCK = NONE"}) + void roundTripsNamedDrops(String actions) throws JSQLParserException { + Alter alter = parse("ALTER TABLE t " + actions); + assertEquals("ALTER TABLE t " + actions, alter.toString()); + assertRoundTrip(alter); + } + + @Test + void namesAndKindsAreEditableWithoutColumnLists() throws JSQLParserException { + Alter alter = parse("ALTER TABLE t DROP FOREIGN KEY fk1, DROP CHECK c1"); + AlterExpression foreign = alter.getAlterExpressions().get(0); + AlterExpression check = alter.getAlterExpressions().get(1); + assertEquals(AlterOperation.DROP_FOREIGN_KEY, foreign.getOperation()); + assertEquals("fk1", foreign.getConstraintName()); + assertNull(foreign.getPkColumns()); + assertEquals(AlterOperation.DROP_CHECK, check.getOperation()); + assertEquals("c1", check.getConstraintName()); + check.setConstraintName("`new check`"); + foreign.setConstraintName("fk2"); + assertEquals("ALTER TABLE t DROP FOREIGN KEY fk2, DROP CHECK `new check`", + alter.toString()); + assertRoundTrip(alter); + } + + @Test + void constructedActionsUseTheSameRendererAsParsedActions() throws JSQLParserException { + for (AlterOperation operation : List.of(AlterOperation.DROP_FOREIGN_KEY, + AlterOperation.DROP_CHECK)) { + Alter alter = new Alter(); + alter.setTable(new Table("t")); + alter.addAlterExpression(new AlterExpression().withOperation(operation) + .withConstraintName("`target constraint`")); + Alter parsed = parse(alter.toString()); + assertEquals(operation, parsed.getAlterExpressions().get(0).getOperation()); + assertEquals("`target constraint`", + parsed.getAlterExpressions().get(0).getConstraintName()); + assertRoundTrip(alter); + // Editing the operation on either concrete class must have the same effect. + parsed.getAlterExpressions().get(0).setOperation(AlterOperation.DROP_CHECK); + assertEquals("ALTER TABLE t DROP CHECK `target constraint`", parsed.toString()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"DROP FOREIGN KEY (id)", "DROP UNIQUE (a, b)", + "DROP PRIMARY KEY", "DROP CONSTRAINT IF EXISTS ck CASCADE", "DROP (a, b)", + "DROP COLUMN c", "DROP INDEX idx"}) + void preservesDefaultDropForms(String action) throws JSQLParserException { + String sql = "ALTER TABLE t " + action; + Alter alter = (Alter) CCJSqlParserUtil.parse(sql); + assertEquals(sql, alter.toString().trim()); + } + + private static Alter parse(String sql) throws JSQLParserException { + return (Alter) CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.MYSQL)); + } + + private static void assertRoundTrip(Alter alter) throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + alter.accept(new StatementDeParser(sql), null); + assertEquals(alter.toString(), sql.toString()); + assertEquals(alter.toString(), parse(sql.toString()).toString()); + } +} From f56eb3f641757be236fbe8beb8a75cdb801c50b8 Mon Sep 17 00:00:00 2001 From: Minjae Lee Date: Thu, 24 Sep 2026 18:51:24 +0900 Subject: [PATCH 004/234] feat: attach PostgreSQL constraints to existing indexes (#2676) Signed-off-by: minleejae --- .../create/table/ConstraintUsingIndex.java | 63 ++++++++++ .../validation/validator/AlterValidator.java | 8 +- .../net/sf/jsqlparser/parser/JSqlParserCC.jjt | 18 +++ src/site/sphinx/usage.rst | 23 ++++ .../PostgreSqlConstraintUsingIndexTest.java | 111 ++++++++++++++++++ 5 files changed, 222 insertions(+), 1 deletion(-) create mode 100644 src/main/java/net/sf/jsqlparser/statement/create/table/ConstraintUsingIndex.java create mode 100644 src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlConstraintUsingIndexTest.java diff --git a/src/main/java/net/sf/jsqlparser/statement/create/table/ConstraintUsingIndex.java b/src/main/java/net/sf/jsqlparser/statement/create/table/ConstraintUsingIndex.java new file mode 100644 index 0000000000..f7f1798b8a --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/table/ConstraintUsingIndex.java @@ -0,0 +1,63 @@ +/*- + * #%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.table; + +import java.util.function.Consumer; +import net.sf.jsqlparser.expression.Expression; + +/** + * A PostgreSQL UNIQUE or PRIMARY KEY constraint backed by an existing index. The referenced index + * is distinct from the constraint name and from a newly declared index. + */ +public class ConstraintUsingIndex extends NamedConstraint { + private String existingIndexName; + + public ConstraintUsingIndex() { + setType("UNIQUE"); + } + + /** Returns the referenced index identifier, retaining SQL quotes. */ + public String getExistingIndexName() { + return existingIndexName; + } + + public void setExistingIndexName(String existingIndexName) { + this.existingIndexName = existingIndexName; + } + + public ConstraintUsingIndex withExistingIndexName(String existingIndexName) { + setExistingIndexName(existingIndexName); + return this; + } + + @Override + public ConstraintUsingIndex withName(String name) { + super.withName(name); + return this; + } + + @Override + public ConstraintUsingIndex withType(String type) { + super.withType(type); + return this; + } + + public ConstraintUsingIndex withConstraintAttributes(ConstraintAttributes attributes) { + setConstraintAttributes(attributes); + return this; + } + + @Override + public void appendTo(StringBuilder sql, Consumer expressionPrinter) { + appendConstraintPrefixTo(sql); + sql.append(getType()).append(" USING INDEX ").append(existingIndexName); + appendConstraintAttributesTo(sql); + } +} 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 7702630e0f..f1b4ccd545 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 @@ -20,6 +20,7 @@ import net.sf.jsqlparser.statement.alter.AlterExpression.ColumnSetNotNull; import net.sf.jsqlparser.statement.alter.AlterOperation; import net.sf.jsqlparser.statement.create.table.DefaultConstraint; +import net.sf.jsqlparser.statement.create.table.ConstraintUsingIndex; import net.sf.jsqlparser.util.TableDefinitionTraversal; import net.sf.jsqlparser.util.validation.ValidationCapability; import net.sf.jsqlparser.util.validation.ValidationUtil; @@ -82,7 +83,12 @@ public void validate(Alter alter, AlterExpression e) { validateOptionalColumnNames(c, e.getUkColumns(), NamedObject.uniqueConstraint); } - if (e.getIndex() instanceof DefaultConstraint) { + if (e.getIndex() instanceof ConstraintUsingIndex) { + ConstraintUsingIndex constraint = (ConstraintUsingIndex) e.getIndex(); + validateOptionalName(c, NamedObject.constraint, constraint.getName(), null, false, + NamedObject.table); + validateName(c, NamedObject.index, constraint.getExistingIndexName()); + } else if (e.getIndex() instanceof DefaultConstraint) { validateOptionalName(c, NamedObject.constraint, e.getIndex().getName(), null, false, NamedObject.table); } else if (e.getIndex() != null) { diff --git a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt index 8952a22fe4..c9e4becec1 100644 --- a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt +++ b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt @@ -14846,6 +14846,18 @@ Index CreateTableConstraint(): { Index index; } { index=TableConstraint(true) { return index; } } +/** Attaches an existing PostgreSQL index without declaring new index columns. */ +ConstraintUsingIndex PostgreSqlConstraintUsingIndex(): +{ ConstraintUsingIndex constraint = new ConstraintUsingIndex(); String name; } +{ + [ name=RelObjectName() { constraint.setName(name); } ] + ( { constraint.setType("UNIQUE"); } + | { constraint.setType("PRIMARY KEY"); } ) + name=RelObjectName() { constraint.setExistingIndexName(name); } + PostgreSqlConstraintAttributes(constraint) + { return constraint; } +} + /** Shared table-constraint body; index option boundaries depend on CREATE versus ALTER. */ Index TableConstraint(boolean createContext): { @@ -17264,6 +17276,12 @@ AlterExpression AlterExpressionAddAlterModify(): alterExp.setIndex(index); } | + LOOKAHEAD([ RelObjectName() ] + ( | ) , + { alterExp.getOperation() == AlterOperation.ADD + && Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) }) + index=PostgreSqlConstraintUsingIndex() { alterExp.setIndex(index); } + | LOOKAHEAD({ alterExp.getOperation() == AlterOperation.ADD && (Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) || Dialect.MYSQL.name().equals(getAsString(Feature.dialect))) diff --git a/src/site/sphinx/usage.rst b/src/site/sphinx/usage.rst index ef25ee681f..51eaa8c59a 100644 --- a/src/site/sphinx/usage.rst +++ b/src/site/sphinx/usage.rst @@ -1342,3 +1342,26 @@ This API identifies expression metadata rather than performing database validation. Precision reports the requested value, without applying defaults, server range checks or clamping. For example, PostgreSQL accepts precision 7 with a warning and clamps it to 6, whereas MySQL rejects it. + +Attach a PostgreSQL constraint to an existing index +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +With ``Dialect.POSTGRESQL``, ``ALTER TABLE ... ADD UNIQUE USING INDEX`` and +``ADD PRIMARY KEY USING INDEX`` expose a ``ConstraintUsingIndex`` through +``AlterExpression.getIndex()``. Its ``getName()`` is the optional new constraint +name, while ``getExistingIndexName()`` identifies the existing index. This is +separate from an index declaration's name, columns and access method. + +.. code-block:: java + + Alter alter = (Alter) CCJSqlParserUtil.parse( + "ALTER TABLE t ADD CONSTRAINT uq UNIQUE USING INDEX i", + parser -> parser.withDialect(Dialect.POSTGRESQL)); + ConstraintUsingIndex constraint = (ConstraintUsingIndex) + alter.getAlterExpressions().get(0).getIndex(); + constraint.setExistingIndexName("replacement_index"); + constraint.setName("replacement_constraint"); + +``getConstraintAttributes()`` exposes deferrability and initial timing when +present. The same AST can be constructed with ``new ConstraintUsingIndex()`` +and its fluent ``withName``, ``withType`` and ``withExistingIndexName`` methods. diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlConstraintUsingIndexTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlConstraintUsingIndexTest.java new file mode 100644 index 0000000000..d9cb97f841 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlConstraintUsingIndexTest.java @@ -0,0 +1,111 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; +import java.util.ArrayList; +import java.util.List; +import java.util.Set; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.schema.Table; +import net.sf.jsqlparser.statement.create.table.ConstraintUsingIndex; +import net.sf.jsqlparser.statement.create.table.Index; +import net.sf.jsqlparser.util.TablesNamesFinder; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import net.sf.jsqlparser.util.validation.ValidationContext; +import net.sf.jsqlparser.util.validation.metadata.Named; +import net.sf.jsqlparser.util.validation.metadata.NamedObject; +import net.sf.jsqlparser.util.validation.metadata.DatabaseMetaDataValidation; +import net.sf.jsqlparser.util.validation.validator.AlterValidator; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class PostgreSqlConstraintUsingIndexTest { + @ParameterizedTest + @ValueSource(strings = {"UNIQUE USING INDEX i", "PRIMARY KEY USING INDEX i", + "CONSTRAINT uq UNIQUE USING INDEX i DEFERRABLE INITIALLY DEFERRED", + "CONSTRAINT pk PRIMARY KEY USING INDEX i NOT DEFERRABLE INITIALLY IMMEDIATE", + "CONSTRAINT \"Unique Name\" UNIQUE USING INDEX \"Index Name\""}) + void roundTripsExistingIndexConstraints(String body) throws JSQLParserException { + String sql = "ALTER TABLE t ADD " + body; + Alter alter = parse(sql); + ConstraintUsingIndex constraint = assertInstanceOf(ConstraintUsingIndex.class, + alter.getAlterExpressions().get(0).getIndex()); + assertNull(constraint.getColumns()); + assertNull(constraint.getIndexName()); + assertNull(constraint.getUsing()); + assertEquals(sql, alter.toString()); + roundTrip(alter); + } + + @Test + void supportsMutationAndConstruction() throws JSQLParserException { + Alter alter = parse("ALTER TABLE t ADD CONSTRAINT uq UNIQUE USING INDEX i DEFERRABLE"); + ConstraintUsingIndex constraint = + (ConstraintUsingIndex) alter.getAlterExpressions().get(0).getIndex(); + assertEquals(Boolean.TRUE, constraint.getConstraintAttributes().getDeferrable()); + constraint.setName("pk"); + constraint.setType("PRIMARY KEY"); + constraint.setExistingIndexName("other_index"); + assertEquals(Index.Kind.PRIMARY_KEY, constraint.getKind()); + assertEquals( + "ALTER TABLE t ADD CONSTRAINT pk PRIMARY KEY USING INDEX other_index DEFERRABLE", + alter.toString()); + roundTrip(alter); + Alter created = new Alter().withTable(new Table("t")); + created.addAlterExpressions(new AlterExpression().withOperation(AlterOperation.ADD) + .withIndex(new ConstraintUsingIndex().withName("uq").withExistingIndexName("i"))); + assertEquals("ALTER TABLE t ADD CONSTRAINT uq UNIQUE USING INDEX i", created.toString()); + roundTrip(created); + } + + @Test + void distinguishesTableAndIndexAndNewConstraint() throws JSQLParserException { + Alter alter = parse("ALTER TABLE t ADD CONSTRAINT uq UNIQUE USING INDEX i"); + assertEquals(Set.of("t"), new TablesNamesFinder().getTables(alter)); + List visited = new ArrayList<>(); + DatabaseMetaDataValidation metadata = named -> { + visited.add(named); + return named.getNamedObject() != NamedObject.constraint; + }; + AlterValidator validator = new AlterValidator(); + validator.setContext(new ValidationContext().setCapabilities(List.of(metadata))); + validator.validate(alter); + assertTrue(validator.getValidationErrors().isEmpty()); + assertTrue(visited.stream() + .anyMatch(n -> n.getNamedObject() == NamedObject.index && "i".equals(n.getFqn()))); + assertTrue(visited.stream().anyMatch( + n -> n.getNamedObject() == NamedObject.constraint && "uq".equals(n.getFqn()))); + } + + @Test + void preservesOrdinaryConstraintsAndActionBoundaries() throws JSQLParserException { + roundTrip(parse("ALTER TABLE t ADD CONSTRAINT uq UNIQUE (id)")); + Alter alter = parse("ALTER TABLE t ADD UNIQUE USING INDEX i, ADD COLUMN extra INT"); + assertEquals(2, alter.getAlterExpressions().size()); + roundTrip(alter); + String oracle = "ALTER TABLE t ADD CONSTRAINT pk PRIMARY KEY (id) USING INDEX i"; + assertEquals(oracle, CCJSqlParserUtil.parse(oracle).toString()); + } + + private static Alter parse(String sql) throws JSQLParserException { + return (Alter) CCJSqlParserUtil.parse(sql, p -> p.withDialect(Dialect.POSTGRESQL)); + } + + private static void roundTrip(Alter alter) throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + alter.accept(new StatementDeParser(sql), null); + assertEquals(alter.toString(), sql.toString()); + assertEquals(sql.toString(), parse(sql.toString()).toString()); + } +} From bdbbde48f25156a00c0941653f480722eaa67498 Mon Sep 17 00:00:00 2001 From: Minjae Lee Date: Thu, 24 Sep 2026 18:52:09 +0900 Subject: [PATCH 005/234] fix: accept identity RESTART values without WITH (#2677) Signed-off-by: minleejae --- .../statement/alter/IdentityAlteration.java | 6 ++ .../net/sf/jsqlparser/parser/JSqlParserCC.jjt | 2 +- src/site/sphinx/usage.rst | 7 ++ .../alter/IdentityRestartValueTest.java | 84 +++++++++++++++++++ 4 files changed, 98 insertions(+), 1 deletion(-) create mode 100644 src/test/java/net/sf/jsqlparser/statement/alter/IdentityRestartValueTest.java diff --git a/src/main/java/net/sf/jsqlparser/statement/alter/IdentityAlteration.java b/src/main/java/net/sf/jsqlparser/statement/alter/IdentityAlteration.java index fdc8949e65..c5c918fc5d 100644 --- a/src/main/java/net/sf/jsqlparser/statement/alter/IdentityAlteration.java +++ b/src/main/java/net/sf/jsqlparser/statement/alter/IdentityAlteration.java @@ -61,6 +61,7 @@ public void setParameters(List parameters) { this.parameters = parameters == null ? null : new ArrayList<>(parameters); } + /** Returns the restart value, or null for a bare RESTART using the sequence start value. */ public Long getRestartWith() { return restartWith; } @@ -69,6 +70,11 @@ public void setRestartWith(Long restartWith) { this.restartWith = restartWith; } + public IdentityAlteration withRestartWith(Long restartWith) { + setRestartWith(restartWith); + return this; + } + public boolean isIfExists() { return ifExists; } diff --git a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt index c9e4becec1..af5849dc2a 100644 --- a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt +++ b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt @@ -16319,7 +16319,7 @@ IdentityAlteration ColumnIdentityAlteration(): } ) | - [ LOOKAHEAD(2) restart=SequenceParameterValue() ] { + [ LOOKAHEAD(1) [ ] restart=SequenceParameterValue() ] { alteration = new IdentityAlteration(IdentityAlteration.Kind.RESTART); alteration.setRestartWith(restart); } diff --git a/src/site/sphinx/usage.rst b/src/site/sphinx/usage.rst index 51eaa8c59a..42be5baa07 100644 --- a/src/site/sphinx/usage.rst +++ b/src/site/sphinx/usage.rst @@ -316,6 +316,13 @@ Table constraints expose ``Index.getNullsDistinct()``, ``getIncludeColumns()``, Identity alterations are available as ``ColumnDataType.getIdentityAlterations()``. Sequence ownership is shared by ``CreateSequence`` and ``AlterSequence`` through ``Sequence.getOwnership()``: ``null`` means omitted, ``isNone()`` means explicit ``OWNED BY NONE``, and ``getColumn()`` identifies an owner. ``TablesNamesFinder`` includes ``LIKE`` sources and sequence owners without treating sequence or type names as tables. See `ALTER TABLE `_ and `ALTER SEQUENCE `_. +For identity columns, ``RESTART 20`` and ``RESTART WITH 20`` produce the same +``IdentityAlteration`` with kind ``RESTART`` and ``getRestartWith() == 20L``. +The renderer consistently uses ``RESTART WITH 20``. A null restart value means +bare ``RESTART``, which uses the sequence's configured start value. Call +``setRestartWith`` to edit a parsed action or construct one with +``new IdentityAlteration(Kind.RESTART).withRestartWith(20L)``. + Structured column attributes ============================ diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/IdentityRestartValueTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/IdentityRestartValueTest.java new file mode 100644 index 0000000000..c73b2fc103 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/alter/IdentityRestartValueTest.java @@ -0,0 +1,84 @@ +/*- + * #%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 org.junit.jupiter.api.Assertions.*; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.util.deparser.StatementDeParser; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class IdentityRestartValueTest { + @ParameterizedTest + @ValueSource(strings = {"20", "WITH 20", "+20", "-20", "WITH -20", "9223372036854775807"}) + void representsOptionalWithUsingTheSameValue(String value) throws JSQLParserException { + for (Dialect dialect : new Dialect[] {null, Dialect.POSTGRESQL}) { + Alter alter = parse("ALTER TABLE t ALTER COLUMN id RESTART " + value, dialect); + IdentityAlteration restart = identity(alter).get(0); + assertEquals(IdentityAlteration.Kind.RESTART, restart.getKind()); + assertEquals(Long.valueOf(value.replace("WITH ", "")), restart.getRestartWith()); + roundTrip(alter, dialect); + } + } + + @Test + void editsAndConstructsRestartAndPreservesBareRestart() throws JSQLParserException { + Alter alter = parse("ALTER TABLE t ALTER COLUMN id RESTART", Dialect.POSTGRESQL); + assertNull(identity(alter).get(0).getRestartWith()); + identity(alter).get(0).setRestartWith(20L); + assertEquals("ALTER TABLE t ALTER COLUMN id RESTART WITH 20", alter.toString()); + roundTrip(alter, Dialect.POSTGRESQL); + alter.getAlterExpressions().get(0).getColDataTypeList().get(0).setIdentityAlterations( + List.of(new IdentityAlteration(IdentityAlteration.Kind.RESTART) + .withRestartWith(40L))); + assertEquals("ALTER TABLE t ALTER COLUMN id RESTART WITH 40", alter.toString()); + roundTrip(alter, Dialect.POSTGRESQL); + identity(alter).get(0).setRestartWith(null); + assertEquals("ALTER TABLE t ALTER COLUMN id RESTART", alter.toString()); + } + + @Test + void respectsIdentityAndAlterActionBoundaries() throws JSQLParserException { + Alter alter = parse( + "ALTER TABLE t ALTER COLUMN id SET CACHE 10 RESTART 20 SET NO CYCLE, ADD COLUMN extra INT", + Dialect.POSTGRESQL); + assertEquals(3, identity(alter).size()); + assertEquals(2, alter.getAlterExpressions().size()); + roundTrip(alter, Dialect.POSTGRESQL); + roundTrip(parse("ALTER TABLE t ALTER COLUMN id RESTART SET CACHE 10", Dialect.POSTGRESQL), + Dialect.POSTGRESQL); + assertThrows(JSQLParserException.class, + () -> parse("ALTER TABLE t ALTER COLUMN id RESTART WITH", Dialect.POSTGRESQL)); + } + + private static List identity(Alter alter) { + return alter.getAlterExpressions().get(0).getColDataTypeList().get(0) + .getIdentityAlterations(); + } + + private static Alter parse(String sql, Dialect dialect) throws JSQLParserException { + return (Alter) CCJSqlParserUtil.parse(sql, p -> { + if (dialect != null) { + p.withDialect(dialect); + } + }); + } + + private static void roundTrip(Alter alter, Dialect dialect) throws JSQLParserException { + StringBuilder sql = new StringBuilder(); + alter.accept(new StatementDeParser(sql), null); + assertEquals(alter.toString(), sql.toString()); + assertEquals(sql.toString(), parse(sql.toString(), dialect).toString()); + } +} From 37b66b2d1a4751d720b890d059ba0e854b71fde9 Mon Sep 17 00:00:00 2001 From: Minjae Lee Date: Thu, 24 Sep 2026 18:53:18 +0900 Subject: [PATCH 006/234] feat: model qualified PostgreSQL exclusion operators (#2678) Signed-off-by: minleejae --- .../create/table/ExclusionOperator.java | 68 ++++++++++++++ .../statement/create/table/Index.java | 20 +++- .../net/sf/jsqlparser/parser/JSqlParserCC.jjt | 26 ++++- src/site/sphinx/usage.rst | 9 ++ .../PostgreSqlExclusionOperatorTest.java | 94 +++++++++++++++++++ 5 files changed, 210 insertions(+), 7 deletions(-) create mode 100644 src/main/java/net/sf/jsqlparser/statement/create/table/ExclusionOperator.java create mode 100644 src/test/java/net/sf/jsqlparser/statement/alter/PostgreSqlExclusionOperatorTest.java diff --git a/src/main/java/net/sf/jsqlparser/statement/create/table/ExclusionOperator.java b/src/main/java/net/sf/jsqlparser/statement/create/table/ExclusionOperator.java new file mode 100644 index 0000000000..5ae3529a9a --- /dev/null +++ b/src/main/java/net/sf/jsqlparser/statement/create/table/ExclusionOperator.java @@ -0,0 +1,68 @@ +/*- + * #%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.table; + +import java.io.Serializable; + +/** An exclusion operator, optionally qualified and enclosed in PostgreSQL OPERATOR(...). */ +public class ExclusionOperator implements Serializable { + private String schemaName; + private String name; + private boolean useOperatorKeyword; + + public String getSchemaName() { + return schemaName; + } + + public void setSchemaName(String schemaName) { + this.schemaName = schemaName; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public boolean isUseOperatorKeyword() { + return useOperatorKeyword; + } + + public void setUseOperatorKeyword(boolean useOperatorKeyword) { + this.useOperatorKeyword = useOperatorKeyword; + } + + public ExclusionOperator withSchemaName(String schemaName) { + setSchemaName(schemaName); + return this; + } + + public ExclusionOperator withName(String name) { + setName(name); + return this; + } + + public ExclusionOperator withUseOperatorKeyword(boolean useOperatorKeyword) { + setUseOperatorKeyword(useOperatorKeyword); + return this; + } + + /** Returns the qualified name without an OPERATOR wrapper, preserving identifier quotes. */ + public String getQualifiedName() { + return (schemaName == null ? "" : schemaName + ".") + name; + } + + @Override + public String toString() { + return useOperatorKeyword ? "OPERATOR(" + getQualifiedName() + ")" : getQualifiedName(); + } +} diff --git a/src/main/java/net/sf/jsqlparser/statement/create/table/Index.java b/src/main/java/net/sf/jsqlparser/statement/create/table/Index.java index bf1bbbf40e..ffd6bad08c 100644 --- a/src/main/java/net/sf/jsqlparser/statement/create/table/Index.java +++ b/src/main/java/net/sf/jsqlparser/statement/create/table/Index.java @@ -414,16 +414,32 @@ public enum NullOrdering { private List