Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions README.md
Original file line number Diff line number Diff line change
Expand Up @@ -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` |
Expand Down
2 changes: 1 addition & 1 deletion src/main/java/net/sf/jsqlparser/schema/Sequence.java
Original file line number Diff line number Diff line change
Expand Up @@ -187,7 +187,7 @@ public Sequence addParameters(Collection<? extends Parameter> 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));
Expand Down
27 changes: 25 additions & 2 deletions src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
Original file line number Diff line number Diff line change
Expand Up @@ -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; }
|
Expand Down Expand Up @@ -21054,6 +21062,7 @@ IdentityDefinition IdentityDefinition():
List<Sequence.Parameter> parameters = new ArrayList<Sequence.Parameter>();
Sequence.Parameter parameter;
Sequence sequenceName;
boolean hasPersistence = false;
}
{
token=<S_IDENTIFIER> {
Expand All @@ -21069,6 +21078,15 @@ IdentityDefinition IdentityDefinition():
<K_SEQUENCE> <K_NAME> sequenceName=Sequence()
{ parameter = new Sequence.Parameter(Sequence.ParameterType.SEQUENCE_NAME)
.withSequenceName(sequenceName); }
|
LOOKAHEAD({ isKeywordAhead("LOGGED") || getToken(1).kind == K_UNLOGGED })
( token=<S_IDENTIFIER> | token=<K_UNLOGGED> ) {
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); }
Expand Down Expand Up @@ -25832,8 +25850,13 @@ PartitionBound PostgreSqlPartitionBound():
bound.setInExpressions(expressions);
}
|
<K_WITH> "(" <K_MODULUS> modulus=Expression() ","
<K_REMAINDER> remainder=Expression() ")"
<K_WITH> "("
(
<K_MODULUS> modulus=Expression() "," <K_REMAINDER> remainder=Expression()
|
<K_REMAINDER> remainder=Expression() "," <K_MODULUS> modulus=Expression()
)
")"
{
bound = new PartitionBound(PartitionBound.Type.HASH);
bound.setModulus(modulus);
Expand Down
Original file line number Diff line number Diff line change
@@ -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<KeyElement> 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<? extends Expression> 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 <S> 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<String> visitedColumns(Statement statement) {
List<String> columns = new ArrayList<>();
ExpressionVisitorAdapter<Void> expressions = new ExpressionVisitorAdapter<Void>() {
@Override
public <S> 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());
}
}
Loading