From cea764bfdf65e44c83f459d459de77fd16b6b408 Mon Sep 17 00:00:00 2001 From: Minjae Lee <55116920+minleejae@users.noreply.github.com> Date: Sun, 15 Nov 2026 12:37:44 +0900 Subject: [PATCH] fix: parse PostgreSQL DDL key and identity options Preserve CAST/EXTRACT key expressions with the PostgreSQL dialect, accept both HASH bound name orders and retain identity persistence as typed sequence parameters. Add positive, negative and identifier regressions without widening standalone sequence syntax. --- README.md | 1 + .../net/sf/jsqlparser/schema/Sequence.java | 2 +- .../net/sf/jsqlparser/parser/JSqlParserCC.jjt | 27 +- .../create/PostgreSqlDdlKeyOptionsTest.java | 287 ++++++++++++++++++ 4 files changed, 314 insertions(+), 3 deletions(-) create mode 100644 src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlDdlKeyOptionsTest.java diff --git a/README.md b/README.md index 6aab5f3ff4..c9c9451bba 100644 --- a/README.md +++ b/README.md @@ -151,6 +151,7 @@ and missing syntax gets added on demand — [open an issue](https://github.com/J | **PostgreSQL maintenance** | `VACUUM` · `ANALYZE` · `CLUSTER` · `CHECKPOINT` | | **PostgreSQL session statements** | `DISCARD` · `LISTEN` · `UNLISTEN` · `SHOW`/`RESET TIME ZONE`/`TRANSACTION ISOLATION LEVEL`/`SESSION AUTHORIZATION` · `COPY` options from before 9.0 | | **PostgreSQL foreign schema import** | `IMPORT FOREIGN SCHEMA … [LIMIT TO \| EXCEPT (…)] FROM SERVER … INTO … [OPTIONS (…)]` | +| **PostgreSQL table and index options** | Bare `CAST`/`EXTRACT` keys with `Dialect.POSTGRESQL` · either order of HASH partition bound options · identity sequence `LOGGED`/`UNLOGGED` | | **PostgreSQL cursors** | `DECLARE … CURSOR` · `FETCH` · `MOVE` · `CLOSE` | | **PostgreSQL RLS** | `CREATE POLICY` · `ALTER TABLE … ENABLE`/`DISABLE`/`FORCE`/`NO FORCE ROW LEVEL SECURITY` | | **MySQL table maintenance** | `ANALYZE` · `CHECK` · `CHECKSUM` · `OPTIMIZE` · `REPAIR TABLE` | diff --git a/src/main/java/net/sf/jsqlparser/schema/Sequence.java b/src/main/java/net/sf/jsqlparser/schema/Sequence.java index 6125fce3af..ff7cd66a55 100644 --- a/src/main/java/net/sf/jsqlparser/schema/Sequence.java +++ b/src/main/java/net/sf/jsqlparser/schema/Sequence.java @@ -187,7 +187,7 @@ public Sequence addParameters(Collection parameters) { * The available parameters to a sequence */ public enum ParameterType { - INCREMENT_BY, INCREMENT, START_WITH, START, RESTART_WITH, MAXVALUE, NOMAXVALUE, MINVALUE, NOMINVALUE, CYCLE, NOCYCLE, CACHE, NOCACHE, ORDER, NOORDER, KEEP, NOKEEP, SESSION, GLOBAL, NO_MINVALUE, NO_MAXVALUE, NO_CYCLE, SEQUENCE_NAME; + INCREMENT_BY, INCREMENT, START_WITH, START, RESTART_WITH, MAXVALUE, NOMAXVALUE, MINVALUE, NOMINVALUE, CYCLE, NOCYCLE, CACHE, NOCACHE, ORDER, NOORDER, KEEP, NOKEEP, SESSION, GLOBAL, NO_MINVALUE, NO_MAXVALUE, NO_CYCLE, SEQUENCE_NAME, LOGGED, UNLOGGED; public static ParameterType from(String type) { return Enum.valueOf(ParameterType.class, type.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 80a3d42a77..78601571d3 100644 --- a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt +++ b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt @@ -20514,6 +20514,14 @@ KeyElement IndexColumnWithParams(): { } { ( + LOOKAHEAD({ Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) + && getToken(1).kind == K_CAST && getToken(2).kind == OPENING_BRACKET }) expression=CastExpression() + { expressionParenthesized = false; } + | + LOOKAHEAD({ Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) + && getToken(1).kind == K_EXTRACT && getToken(2).kind == OPENING_BRACKET }) expression=ExtractExpression() + { expressionParenthesized = false; } + | LOOKAHEAD({ Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect)) && isFunctionAhead() }) expression=Function() { expressionParenthesized = false; } | @@ -21054,6 +21062,7 @@ IdentityDefinition IdentityDefinition(): List parameters = new ArrayList(); Sequence.Parameter parameter; Sequence sequenceName; + boolean hasPersistence = false; } { token= { @@ -21069,6 +21078,15 @@ IdentityDefinition IdentityDefinition(): sequenceName=Sequence() { parameter = new Sequence.Parameter(Sequence.ParameterType.SEQUENCE_NAME) .withSequenceName(sequenceName); } + | + LOOKAHEAD({ isKeywordAhead("LOGGED") || getToken(1).kind == K_UNLOGGED }) + ( token= | token= ) { + requireDdlSyntax(!hasPersistence, + "Identity sequence persistence cannot be specified more than once"); + hasPersistence = true; + parameter = new Sequence.Parameter(Sequence.ParameterType.valueOf( + token.image.toUpperCase(Locale.ROOT))); + } | parameter=SequenceParameter() ) { parameters.add(parameter); } @@ -25832,8 +25850,13 @@ PartitionBound PostgreSqlPartitionBound(): bound.setInExpressions(expressions); } | - "(" modulus=Expression() "," - remainder=Expression() ")" + "(" + ( + modulus=Expression() "," remainder=Expression() + | + remainder=Expression() "," modulus=Expression() + ) + ")" { bound = new PartitionBound(PartitionBound.Type.HASH); bound.setModulus(modulus); diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlDdlKeyOptionsTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlDdlKeyOptionsTest.java new file mode 100644 index 0000000000..2673683eb3 --- /dev/null +++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlDdlKeyOptionsTest.java @@ -0,0 +1,287 @@ +/*- + * #%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; + +import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed; +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.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.ArrayList; +import java.util.List; +import net.sf.jsqlparser.JSQLParserException; +import net.sf.jsqlparser.expression.CastExpression; +import net.sf.jsqlparser.expression.Expression; +import net.sf.jsqlparser.expression.ExpressionVisitorAdapter; +import net.sf.jsqlparser.expression.ExtractExpression; +import net.sf.jsqlparser.expression.Function; +import net.sf.jsqlparser.expression.LongValue; +import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect; +import net.sf.jsqlparser.parser.CCJSqlParserUtil; +import net.sf.jsqlparser.parser.feature.Feature; +import net.sf.jsqlparser.parser.feature.FeatureConfiguration; +import net.sf.jsqlparser.schema.Column; +import net.sf.jsqlparser.schema.Sequence; +import net.sf.jsqlparser.statement.Statement; +import net.sf.jsqlparser.statement.StatementVisitorAdapter; +import net.sf.jsqlparser.statement.alter.Alter; +import net.sf.jsqlparser.statement.alter.AlterExpressionPartition; +import net.sf.jsqlparser.statement.create.index.CreateIndex; +import net.sf.jsqlparser.statement.create.table.CreateTable; +import net.sf.jsqlparser.statement.create.table.IdentityDefinition; +import net.sf.jsqlparser.statement.create.table.KeyElement; +import net.sf.jsqlparser.statement.create.table.PartitionBound; +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.FeaturesAllowed; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +/** PostgreSQL DDL options verified against PostgreSQL 18.6. */ +class PostgreSqlDdlKeyOptionsTest { + @Test + void keepsSpecialIndexKeyExpressionsAndAttributes() throws JSQLParserException { + CreateIndex index = (CreateIndex) checked("CREATE INDEX ix ON t " + + "(CAST(n AS bigint) int8_ops DESC NULLS LAST, EXTRACT(YEAR FROM d), lower(label))"); + List keys = index.getIndex().getColumns(); + assertEquals(3, keys.size()); + CastExpression cast = assertInstanceOf(CastExpression.class, keys.get(0).getExpression()); + assertEquals("n", assertInstanceOf(Column.class, cast.getLeftExpression()).getColumnName()); + assertEquals("bigint", cast.getColDataType().getDataType()); + assertEquals("int8_ops", keys.get(0).getOperatorClass()); + assertEquals(KeyElement.SortOrder.DESC, keys.get(0).getSortOrder()); + assertEquals(KeyElement.NullOrdering.LAST, keys.get(0).getNullOrdering()); + ExtractExpression extract = + assertInstanceOf(ExtractExpression.class, keys.get(1).getExpression()); + assertEquals("YEAR", extract.getName()); + assertEquals("d", assertInstanceOf(Column.class, extract.getExpression()).getColumnName()); + assertInstanceOf(Function.class, keys.get(2).getExpression()); + keys.forEach(key -> assertFalse(key.isExpressionParenthesized())); + assertEquals(List.of("n", "d", "label"), visitedColumns(index)); + assertEquals(java.util.Set.of("t"), new TablesNamesFinder<>().getTables(index)); + roundTrip(index); + } + + @ParameterizedTest + @ValueSource(strings = {"CAST(n AS bigint)", "EXTRACT(YEAR FROM d)", "lower(label)"}) + void sharesSpecialFunctionsWithPartitionKeys(String expression) throws JSQLParserException { + CreateTable table = (CreateTable) checked("CREATE TABLE t (n integer, d date, label text) " + + "PARTITION BY RANGE (" + expression + ")"); + Expression key = table.getPartitioning().getExpression(); + assertEquals(expression, key.toString()); + Class expressionType = expression.startsWith("CAST") + ? CastExpression.class + : expression.startsWith("EXTRACT") ? ExtractExpression.class : Function.class; + assertInstanceOf(expressionType, key); + roundTrip(table); + String operatorClass = key instanceof CastExpression ? "int8_ops" + : key instanceof ExtractExpression ? "numeric_ops" : "text_ops"; + CreateTable attributed = + (CreateTable) checked("CREATE TABLE t (n integer, d date, label text) " + + "PARTITION BY RANGE (" + expression + " " + operatorClass + ")"); + assertEquals(operatorClass, + attributed.getPartitioning().getKeyColumns().get(0).getOperatorClass()); + assertFalse(attributed.getPartitioning().getKeyColumns().get(0) + .isExpressionParenthesized()); + roundTrip(attributed); + } + + @Test + void specialFunctionNamesStillWorkAsIdentifiers() throws JSQLParserException { + CreateIndex index = + (CreateIndex) checked("CREATE INDEX ix ON t (extract, \"CAST\", \"EXTRACT\")"); + assertEquals(List.of("extract", "\"CAST\"", "\"EXTRACT\""), index.getIndex().getColumns() + .stream().map(KeyElement::getColumnName) + .collect(java.util.stream.Collectors.toList())); + index.getIndex().getColumns().forEach(key -> assertNull(key.getExpression())); + roundTrip(checked("CREATE TABLE t (extract integer) PARTITION BY RANGE (extract)")); + CreateIndex calls = + (CreateIndex) checked("CREATE INDEX ix ON t (\"CAST\"(n), \"EXTRACT\"(d))"); + calls.getIndex().getColumns() + .forEach(key -> assertInstanceOf(Function.class, key.getExpression())); + } + + @Test + void expressionVisitorsAndDeparsersReachSpecialKeys() throws JSQLParserException { + for (String sql : new String[] { + "CREATE INDEX ix ON t (CAST(n AS bigint), EXTRACT(YEAR FROM d))", + "CREATE TABLE t (n integer, d date) PARTITION BY RANGE " + + "(CAST(n AS bigint), EXTRACT(YEAR FROM d))"}) { + Statement statement = checked(sql); + assertEquals(List.of("n", "d"), visitedColumns(statement)); + StringBuilder output = new StringBuilder(); + ExpressionDeParser expressions = new ExpressionDeParser() { + @Override + public StringBuilder visit(Column column, S context) { + return getBuilder().append("mapped_").append(column.getColumnName()); + } + }; + statement.accept(new StatementDeParser(expressions, new SelectDeParser(), output), + null); + assertEquals(sql.replace("CAST(n ", "CAST(mapped_n ") + .replace("FROM d)", "FROM mapped_d)"), output.toString()); + roundTrip(parse(output.toString())); + } + } + + @ParameterizedTest + @ValueSource(strings = {"n + 1", "CAST(n AS bigint) + 1", "EXTRACT(YEAR FROM d) + 1"}) + void arbitraryBareExpressionsStillNeedParentheses(String expression) + throws JSQLParserException { + assertThrows(JSQLParserException.class, + () -> parse("CREATE INDEX ix ON t (" + expression + ")")); + assertThrows(JSQLParserException.class, + () -> parse("CREATE TABLE t (n integer, d date) PARTITION BY RANGE (" + + expression + ")")); + roundTrip(checked("CREATE INDEX ix ON t ((" + expression + "))")); + roundTrip(checked("CREATE TABLE t (n integer, d date) PARTITION BY RANGE ((" + + expression + "))")); + } + + @ParameterizedTest + @ValueSource(strings = {"MODULUS 8, REMAINDER 3", "REMAINDER 3, MODULUS 8"}) + void hashBoundsKeepTheirNamedValuesInEitherOrder(String options) throws JSQLParserException { + for (Dialect dialect : new Dialect[] {null, Dialect.POSTGRESQL}) { + for (boolean attach : new boolean[] {false, true}) { + String prefix = attach ? "ALTER TABLE parent ATTACH PARTITION child " + : "CREATE TABLE child PARTITION OF parent "; + Statement statement = parse(prefix + "FOR VALUES WITH (" + options + ")", dialect); + PartitionBound bound = attach + ? ((AlterExpressionPartition) ((Alter) statement).getAlterExpressions() + .get(0)) + .getPartitionBound() + : ((CreateTable) statement).getPartitionBound(); + assertEquals(PartitionBound.Type.HASH, bound.getType()); + assertEquals(8, assertInstanceOf(LongValue.class, bound.getModulus()).getValue()); + assertEquals(3, assertInstanceOf(LongValue.class, bound.getRemainder()).getValue()); + assertEquals(prefix + "FOR VALUES WITH (MODULUS 8, REMAINDER 3)", + statement.toString()); + roundTrip(statement, dialect); + } + } + } + + @ParameterizedTest + @ValueSource(strings = {"MODULUS 8", "REMAINDER 3", "MODULUS 8, MODULUS 8", + "REMAINDER 3, REMAINDER 3", "MODULUS 8, REMAINDER 3, MODULUS 8", + "REMAINDER 3, MODULUS 8, REMAINDER 3"}) + void rejectsMissingAndDuplicateHashBoundOptions(String options) { + for (String prefix : new String[] {"CREATE TABLE child PARTITION OF parent ", + "ALTER TABLE parent ATTACH PARTITION child "}) { + assertThrows(JSQLParserException.class, + () -> parse(prefix + "FOR VALUES WITH (" + options + ")")); + } + } + + @ParameterizedTest + @ValueSource(strings = {"LOGGED", "UNLOGGED"}) + void identityPersistenceIsAnOptionForCreateAndAdd(String persistence) + throws JSQLParserException { + String definition = "GENERATED ALWAYS AS IDENTITY (SEQUENCE NAME public.ids " + + persistence + " START WITH 10 INCREMENT BY 3)"; + CreateTable table = (CreateTable) checked("CREATE TABLE t (id bigint " + definition + ")"); + Alter alter = (Alter) checked("ALTER TABLE t ALTER COLUMN id ADD " + definition); + IdentityDefinition created = table.getColumnDefinitions().get(0).getColumnOptions().get(0) + .getIdentityDefinition(); + IdentityDefinition added = alter.getAlterExpressions().get(0).getColDataTypeList().get(0) + .getIdentityAlterations().get(0).getIdentityDefinition(); + for (IdentityDefinition identity : new IdentityDefinition[] {created, added}) { + assertEquals(IdentityDefinition.GenerationMode.ALWAYS, identity.getGenerationMode()); + assertEquals(4, identity.getParameters().size()); + Sequence.Parameter option = identity.getParameters().get(1); + assertEquals(persistence, option.getOption().name()); + assertNull(option.getValue()); + assertNull(option.getSequenceName()); + assertEquals("public.ids", identity.getParameters().get(0).getSequenceName() + .getFullyQualifiedName()); + assertEquals(10L, identity.getParameters().get(2).getValue()); + assertEquals(3L, identity.getParameters().get(3).getValue()); + } + assertFalse(table.isUnlogged()); + roundTrip(table); + roundTrip(alter); + FeatureConfiguration configuration = new FeatureConfiguration() + .setValue(Feature.dialect, Dialect.POSTGRESQL.name()); + assertTrue(new Validation(configuration, List.of(FeaturesAllowed.DDL), table.toString(), + alter.toString()).validate().isEmpty()); + } + + @ParameterizedTest + @ValueSource(strings = {"LOGGED UNLOGGED", "UNLOGGED LOGGED", "LOGGED LOGGED", + "UNLOGGED UNLOGGED", "LOGGED 1", "UNLOGGED 1"}) + void rejectsConflictingAndMalformedIdentityPersistence(String options) { + for (String sql : new String[] { + "CREATE TABLE t (id bigint GENERATED ALWAYS AS IDENTITY (" + options + "))", + "ALTER TABLE t ALTER COLUMN id ADD GENERATED ALWAYS AS IDENTITY (" + options + + ")"}) { + assertThrows(JSQLParserException.class, () -> parse(sql), sql); + } + } + + @Test + void identityOptionsDoNotChangeStandaloneSequenceGrammar() { + for (String sql : new String[] {"CREATE SEQUENCE ids LOGGED", + "CREATE SEQUENCE ids UNLOGGED", "ALTER SEQUENCE ids LOGGED", + "ALTER SEQUENCE ids UNLOGGED"}) { + assertThrows(JSQLParserException.class, () -> parse(sql), sql); + } + } + + private static List visitedColumns(Statement statement) { + List columns = new ArrayList<>(); + ExpressionVisitorAdapter expressions = new ExpressionVisitorAdapter() { + @Override + public Void visit(Column column, S context) { + assertEquals("context", context); + columns.add(column.getColumnName()); + return null; + } + }; + statement.accept(new StatementVisitorAdapter<>(new SelectVisitorAdapter<>(expressions)), + "context"); + return columns; + } + + private static Statement checked(String sql) throws JSQLParserException { + return assertSqlCanBeParsedAndDeparsed(sql, false, + parser -> parser.withDialect(Dialect.POSTGRESQL)); + } + + private static Statement parse(String sql) throws JSQLParserException { + return parse(sql, Dialect.POSTGRESQL); + } + + private static Statement parse(String sql, Dialect dialect) throws JSQLParserException { + return CCJSqlParserUtil.parse(sql, parser -> { + if (dialect != null) { + parser.withDialect(dialect); + } + }); + } + + private static void roundTrip(Statement statement) throws JSQLParserException { + roundTrip(statement, Dialect.POSTGRESQL); + } + + private static void roundTrip(Statement statement, Dialect dialect) throws JSQLParserException { + StringBuilder output = new StringBuilder(); + statement.accept(new StatementDeParser(output)); + assertEquals(statement.toString(), output.toString()); + assertEquals(output.toString(), parse(output.toString(), dialect).toString()); + } +}