From 4ec678c68f21f4273a451816d451700e6641cfcb Mon Sep 17 00:00:00 2001 From: minleejae Date: Thu, 19 Nov 2026 09:51:08 +0900 Subject: [PATCH] fix: read PostgreSQL NOT NULL and USING INDEX table constraints without a dialect Signed-off-by: minleejae --- .../net/sf/jsqlparser/parser/JSqlParserCC.jjt | 30 +++++++-- .../alter/AlterAddTableConstraintTest.java | 67 +++++++++++++++++-- 2 files changed, 85 insertions(+), 12 deletions(-) diff --git a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt index 08ae097a6..ac32813fe 100644 --- a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt +++ b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt @@ -3974,6 +3974,15 @@ public class CCJSqlParser extends AbstractJSqlParser { && "CHARSET".equalsIgnoreCase(getToken(2).image); } + /** + * PostgreSQL's table-level NOT NULL and UNIQUE or PRIMARY KEY USING INDEX constraints: read + * with that dialect and without one, never with another dialect. + */ + private boolean isPostgreSqlTableConstraintDialect() { + String dialect = getAsString(Feature.dialect); + return dialect == null || Dialect.POSTGRESQL.name().equals(dialect); + } + private boolean isTableIndexAhead() { switch (getToken(1).kind) { case K_PRIMARY: @@ -4013,6 +4022,15 @@ public class CCJSqlParser extends AbstractJSqlParser { && hasConstraintAttribute(first, body.kind == K_CHECK, source); } + /** + * Whether the action starting at {@code first} is PostgreSQL's table-level + * {@code [CONSTRAINT name] NOT NULL column}. + */ + static boolean isNotNullConstraint(Token first, CCJSqlParserTokenManager source) { + Token body = first.kind == K_CONSTRAINT ? next(next(first, source), source) : first; + return body.kind == K_NOT && next(body, source).kind == K_NULL; + } + /** An unnamed CHECK, a FOREIGN KEY or an EXCLUDE constraint. */ private static boolean isSharedOnlyConstraint(Token first, Token second, Token body, CCJSqlParserTokenManager source) { @@ -22780,8 +22798,7 @@ TableElement TableConstraint(boolean createContext): LOOKAHEAD({ isExcludeConstraintAhead() }) namedConstraint=PostgreSqlExcludeConstraint() { namedConstraint.setName(constraintName); index = namedConstraint; } | - LOOKAHEAD({ Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) - && getToken(1).kind == K_NOT }) + LOOKAHEAD({ isPostgreSqlTableConstraintDialect() && getToken(1).kind == K_NOT }) namedConstraint=PostgreSqlNotNullConstraint() { namedConstraint.setName(constraintName); index = namedConstraint; } ) | @@ -22791,8 +22808,7 @@ TableElement TableConstraint(boolean createContext): | LOOKAHEAD({ isExcludeConstraintAhead() }) index=PostgreSqlExcludeConstraint() | - LOOKAHEAD({ Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) - && getToken(1).kind == K_NOT }) + LOOKAHEAD({ isPostgreSqlTableConstraintDialect() && getToken(1).kind == K_NOT }) index=PostgreSqlNotNullConstraint() ) PostgreSqlConstraintAttributes(index) @@ -26662,7 +26678,7 @@ AlterExpression AlterExpressionAddAlterModify(): LOOKAHEAD([ RelObjectName() ] ( | ) , { alterExp.getOperation() == AlterOperation.ADD - && Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) }) + && isPostgreSqlTableConstraintDialect() }) constraint=PostgreSqlConstraintUsingIndex() { alterExp.setConstraint(constraint); } | LOOKAHEAD({ alterExp.getOperation() == AlterOperation.ADD @@ -26673,7 +26689,9 @@ AlterExpression AlterExpressionAddAlterModify(): || getToken(1).kind == K_CHECK || getToken(1).kind == K_EXCLUDE || getToken(1).kind == K_NOT && Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect))) - || AlterConstraintLookahead.needsSharedTableConstraint(getToken(1), token_source)) }) + || AlterConstraintLookahead.needsSharedTableConstraint(getToken(1), token_source) + || getAsString(Feature.dialect) == null + && AlterConstraintLookahead.isNotNullConstraint(getToken(1), token_source)) }) element=TableConstraint(false) { setAlterTableElement(alterExp, element); } | LOOKAHEAD({ isTableIndexAhead() }) element=TableIndexSpec(false) { diff --git a/src/test/java/net/sf/jsqlparser/statement/alter/AlterAddTableConstraintTest.java b/src/test/java/net/sf/jsqlparser/statement/alter/AlterAddTableConstraintTest.java index ce41db3d3..b4ea82588 100644 --- a/src/test/java/net/sf/jsqlparser/statement/alter/AlterAddTableConstraintTest.java +++ b/src/test/java/net/sf/jsqlparser/statement/alter/AlterAddTableConstraintTest.java @@ -11,7 +11,6 @@ import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertInstanceOf; import static org.junit.jupiter.api.Assertions.assertNull; @@ -27,9 +26,11 @@ import net.sf.jsqlparser.parser.CCJSqlParserUtil; import net.sf.jsqlparser.statement.create.table.CheckConstraint; import net.sf.jsqlparser.statement.create.table.ConstraintAttributes; +import net.sf.jsqlparser.statement.create.table.ConstraintUsingIndex; import net.sf.jsqlparser.statement.create.table.CreateTable; import net.sf.jsqlparser.statement.create.table.ForeignKeyConstraint; import net.sf.jsqlparser.statement.create.table.NamedConstraint; +import net.sf.jsqlparser.statement.create.table.NotNullConstraint; import net.sf.jsqlparser.util.TablesNamesFinder; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; @@ -107,14 +108,68 @@ void formsThatAlreadyParsedKeepTheGenericRepresentation() throws JSQLParserExcep assertEquals("UNIQUE KEY", unique.getConstraintType()); } + @ParameterizedTest + @ValueSource(strings = {"ALTER TABLE t ADD CONSTRAINT nn NOT NULL id", + "ALTER TABLE t ADD NOT NULL id", + "ALTER TABLE t ADD CONSTRAINT nn NOT NULL id NO INHERIT", + "ALTER TABLE t ADD CONSTRAINT nn NOT NULL id NOT VALID", + "ALTER TABLE t ADD CONSTRAINT uk UNIQUE USING INDEX t_idx", + "ALTER TABLE t ADD PRIMARY KEY USING INDEX t_idx", + "ALTER TABLE t ADD CONSTRAINT pk PRIMARY KEY USING INDEX t_idx DEFERRABLE", + "ALTER TABLE t ADD COLUMN c INT, ADD CONSTRAINT nn NOT NULL id, ADD CONSTRAINT uk UNIQUE USING INDEX t_idx"}) + void postgreSqlOnlyFormsParseWithoutADialectAsWithPostgreSql(String sql) + throws JSQLParserException { + Alter withoutDialect = (Alter) CCJSqlParserUtil.parse(sql); + Alter postgreSql = (Alter) CCJSqlParserUtil.parse(sql, + parser -> parser.withDialect(Dialect.POSTGRESQL)); + assertEquals(sql, withoutDialect.toString()); + assertEquals(postgreSql.toString(), withoutDialect.toString()); + for (int i = 0; i < postgreSql.getAlterExpressions().size(); i++) { + AlterExpression expected = postgreSql.getAlterExpressions().get(i); + AlterExpression actual = withoutDialect.getAlterExpressions().get(i); + assertEquals(expected.getOperation(), actual.getOperation()); + assertEquals( + expected.getConstraint() == null ? null : expected.getConstraint().getClass(), + actual.getConstraint() == null ? null : actual.getConstraint().getClass()); + } + } + + @Test + void postgreSqlOnlyFormsExposeTheirConstraintWithoutADialect() throws JSQLParserException { + AlterExpression notNull = ((Alter) CCJSqlParserUtil + .parse("ALTER TABLE t ADD CONSTRAINT nn NOT NULL id")) + .getAlterExpressions().get(0); + NotNullConstraint notNullConstraint = + assertInstanceOf(NotNullConstraint.class, notNull.getConstraint()); + assertEquals("nn", notNullConstraint.getName()); + assertEquals("id", notNullConstraint.getColumn().getColumnName()); + + AlterExpression usingIndex = ((Alter) CCJSqlParserUtil + .parse("ALTER TABLE t ADD CONSTRAINT uk UNIQUE USING INDEX t_idx")) + .getAlterExpressions().get(0); + ConstraintUsingIndex usingIndexConstraint = + assertInstanceOf(ConstraintUsingIndex.class, usingIndex.getConstraint()); + assertEquals("uk", usingIndexConstraint.getName()); + assertEquals("t_idx", usingIndexConstraint.getExistingIndexName()); + } + + @Test + void tableLevelNotNullParsesInCreateTableWithoutADialect() throws JSQLParserException { + String sql = "CREATE TABLE t (id INT, CONSTRAINT nn NOT NULL id NO INHERIT)"; + CreateTable createTable = (CreateTable) CCJSqlParserUtil.parse(sql); + assertEquals(sql, createTable.toString()); + assertEquals(CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(Dialect.POSTGRESQL)) + .toString(), createTable.toString()); + } + @ParameterizedTest @ValueSource(strings = {"ALTER TABLE t ADD CONSTRAINT nn NOT NULL id", "ALTER TABLE t ADD CONSTRAINT uk UNIQUE USING INDEX t_idx"}) - void postgreSqlOnlyFormsStillRequireThePostgreSqlDialect(String sql) { - assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql)); - assertDoesNotThrow( - () -> CCJSqlParserUtil.parse(sql, - parser -> parser.withDialect(Dialect.POSTGRESQL))); + void postgreSqlOnlyFormsAreStillRejectedWithAnotherDialect(String sql) { + for (Dialect dialect : new Dialect[] {Dialect.MYSQL, Dialect.ORACLE}) { + assertThrows(JSQLParserException.class, + () -> CCJSqlParserUtil.parse(sql, parser -> parser.withDialect(dialect))); + } } @Test